Load just part of an image in python
This might be a silly question, but...
I have several thousand images that I would like to load into Python and then convert into numpy arrays. Obviously this goes a little slowly. But, I am actually only interested in a small portion of each image. (The same portion, just 100x100 pixels in the center of the image.)
Is there any way to load just part of the image to make things go faster?
Here is some sample code where I generate some sample images, save them, and load them back in.
import numpy as np
import matplotlib.pyplot as plt
import Image, time
#Generate sample images
num_images = 5
for i in range(0,num_images):
Z = np.random.rand(2000,2000)
print 'saving %i'%i
plt.imsave('%03i.png'%i,Z)
%load the images
for i in range(0,num_images):
t = time.time()
im = Image.open('%03i.png'%i)
w,h = im.size
imc = im.crop((w-50,h-50,w+50,h+50))
print 'Time to open: %.4f seconds'%(time.time()-t)
#convert them to numpy arrays
data = np.array(imc)
While you can't get much faster than PIL crop in a single thread, you can use multiple cores to speed up everything! :)
I ran the below code on my 8 core i7 machine as well as my 7 year old, two core, barely 2ghz laptop. Both saw significant improvements in run time. Much as you would expect, the improvement was dependent on the number of cores available.
The core of your code is the same, I just separated the looping from the actual computation so that the function could be applies to a list of values in parallel.
So, this:
for i in range(0,num_images):
t = time.time()
im = Image.open('%03i.png'%i)
w,h = im.size
imc = im.crop((w-50,h-50,w+50,h+50))
print 'Time to open: %.4f seconds'%(time.time()-t)
#convert them to numpy arrays
data = np.array(imc)
Became:
def convert(filename):
im = Image.open(filename)
w,h = im.size
imc = im.crop((w-50,h-50,w+50,h+50))
return numpy.array(imc)
The key to the speedup is the Pool feature of the multiprocessing library. It makes it trivial to run things across multiple processors.
Full code:
import os
import time
import numpy
from PIL import Image
from multiprocessing import Pool
# Path to where my test images are stored
img_folder = os.path.join(os.getcwd(), 'test_images')
# Collects all of the filenames for the images
# I want to process
images = [os.path.join(img_folder,f)
for f in os.listdir(img_folder)
if '.jpeg' in f]
# Your code, but wrapped up in a function
def convert(filename):
im = Image.open(filename)
w,h = im.size
imc = im.crop((w-50,h-50,w+50,h+50))
return numpy.array(imc)
def main():
# This is the hero of the code. It creates pool of
# worker processes across which you can "map" a function
pool = Pool()
t = time.time()
# We run it normally (single core) first
np_arrays = map(convert, images)
print 'Time to open %i images in single thread: %.4f seconds'%(len(images), time.time()-t)
t = time.time()
# now we run the same thing, but this time leveraging the worker pool.
np_arrays = pool.map(convert, images)
print 'Time to open %i images with multiple threads: %.4f seconds'%(len(images), time.time()-t)
if __name__ == '__main__':
main()
Pretty basic. Only a few extra lines of code, and a little refactoring to move the conversion bit into its own function. The results speak for themselves:
Results:
8-Core i7
Time to open 858 images in single thread: 6.0040 seconds
Time to open 858 images with multiple threads: 1.4800 seconds
2-Core Intel Duo
Time to open 858 images in single thread: 8.7640 seconds
Time to open 858 images with multiple threads: 4.6440 seconds
So there ya go! Even if you have a super old 2 core machine you can halve the time you spend opening and processing your images.
Caveats
Memory. If you're processing 1000s of images, you're probably going to pop Pythons Memory limit at some point. To get around this, you'll just have to process the data in chunks. You can still leverage all of the multiprocessing goodness, just in smaller bites. Something like:
for i in range(0, len(images), chunk_size):
results = pool.map(convert, images[i : i+chunk_size])
# rest of code.
Save your files as uncompressed 24-bit BMPs. These store pixel data in a very regular way. Check out the "Image Data" portion of this diagram from Wikipedia. Note that most of the complexity in the diagram is just from the headers:
For example, let's say you are storing this image (here shown zoomed in):
This is what the pixel data section looks like, if it's stored as a 24-bit uncompressed BMP. Note that the data is stored bottom-up, for some reason, and in BGR form instead of RGB, so the first line in the file is the bottom-most line of the image, the second line is the second-bottom-most, etc:
00 00 FF FF FF FF 00 00
FF 00 00 00 FF 00 00 00
That data is explained as follows:
| First column | Second Column | Padding
-----------+----------------+-----------------+-----------
Second Row | 00 00 FF | FF FF FF | 00 00
-----------+----------------+-----------------+-----------
First Row | FF 00 00 | 00 FF 00 | 00 00
-----------+----------------+-----------------+-----------
or:
| First column | Second Column | Padding
-----------+----------------+-----------------+-----------
Second Row | red | white | 00 00
-----------+----------------+-----------------+-----------
First Row | blue | green | 00 00
-----------+----------------+-----------------+-----------
The padding is there to pad the row size to a multiple of 4 bytes.
So, all you have to do is implement a reader for this particular file format, and then calculate the byte offset of where you have to start and stop reading each row:
def calc_bytes_per_row(width, bytes_per_pixel):
res = width * bytes_per_pixel
if res % 4 != 0:
res += 4 - res % 4
return res
def calc_row_offsets(pixel_array_offset, bmp_width, bmp_height, x, y, row_width):
if x + row_width > bmp_width:
raise ValueError("This is only for calculating offsets within a row")
bytes_per_row = calc_bytes_per_row(bmp_width, 3)
whole_row_offset = pixel_array_offset + bytes_per_row * (bmp_height - y - 1)
start_row_offset = whole_row_offset + x * 3
end_row_offset = start_row_offset + row_width * 3
return (start_row_offset, end_row_offset)
Then you just have to process the proper byte offsets. For example, say you want to read the 400x400 chunk starting at position 500x500 in a 10000x10000 bitmap:
def process_row_bytes(row_bytes):
... some efficient way to process the bytes ...
bmpf = open(..., "rb")
pixel_array_offset = ... extract from bmp header ...
bmp_width = 10000
bmp_height = 10000
start_x = 500
start_y = 500
end_x = 500 + 400
end_y = 500 + 400
for cur_y in xrange(start_y, end_y):
start, end = calc_row_offsets(pixel_array_offset,
bmp_width, bmp_height,
start_x, cur_y,
end_x - start_x)
bmpf.seek(start)
cur_row_bytes = bmpf.read(end - start)
process_row_bytes(cur_row_bytes)
Note that it's important how you process the bytes. You can probably do something clever using PIL and just dumping the pixel data into it but I'm not entirely sure. If you do it in an inefficient manner then it might not be worth it. If speed is a huge concern, you might consider writing it with pyrex or implementing the above in C and just calling it from Python.
Oh I just realized there might be a far, far simpler way than doing what I wrote above regarding the BMP files.
If you are generating the image files anyway, and you always know which portion you want to read, simply save that portion out as another image file while you're generating it:
import numpy as np
import matplotlib.pyplot as plt
import Image
#Generate sample images
num_images = 5
for i in range(0,num_images):
Z = np.random.rand(2000, 2000)
plt.imsave('%03i.png'%i, Z)
snipZ = Z[200:300, 200:300]
plt.imsave('%03i.snip.png'%i, snipZ)
#load the images
for i in range(0,num_images):
im = Image.open('%03i.snip.png'%i)
#convert them to numpy arrays
data = np.array(im)