{"id":835,"date":"2013-05-02T15:45:41","date_gmt":"2013-05-02T19:45:41","guid":{"rendered":"https:\/\/blogs.mathworks.com\/steve\/?p=835"},"modified":"2019-11-01T09:16:19","modified_gmt":"2019-11-01T13:16:19","slug":"jpeg-versus-png-lossy-and-lossless-image-compression","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/steve\/2013\/05\/02\/jpeg-versus-png-lossy-and-lossless-image-compression\/","title":{"rendered":"JPEG and PNG – lossy and lossless image compression"},"content":{"rendered":"\r\n

I was reviewing enhancement requests recently when I came across this one: Add support for a 'Quality' parameter when using imwrite<\/tt> to write a PNG file, just like you can currently do when writing a JPEG file.<\/i><\/p>

Well, there is actually a pretty good reason why there is no 'Quality' parameter for writing PNG files, but it's not an obvious reason unless you know more about the differences between various image compression methods.<\/p>

A very important characteristic of a compression method is whether it is lossless<\/i> or lossy<\/i>. With a lossless<\/i> compression method, the original data can be recovered exactly. When you make a \"zip\" file on your computer, this is what you certainly expect.<\/p>

Here's an example: I can use gzip<\/tt> to compress the MATLAB script file I'm using for this blog post.<\/p>

gzip('lossless_lossy.m'<\/span>);\r\ndir('lossless_lossy.*'<\/span>)\r\n<\/pre>
\r\nlossless_lossy.m     lossless_lossy.m.gz  \r\n\r\n<\/pre>
Let's compare their sizes to see if the output of gzip<\/tt> is really compressed.<\/p>
d1 = dir('lossless_lossy.m'<\/span>);\r\nd1.bytes\r\n<\/pre>
\r\nans =\r\n\r\n        4098\r\n\r\n<\/pre>
d2 = dir('lossless_lossy.m.gz'<\/span>);\r\nd2.bytes\r\n<\/pre>
\r\nans =\r\n\r\n        1785\r\n\r\n<\/pre>
Indeed, the compressed does actually have fewer bytes. Can we get the original file back exactly?<\/p>
gunzip('lossless_lossy.m.gz'<\/span>,'.\/tmp'<\/span>)\r\nisequal(fileread('lossless_lossy.m'<\/span>),fileread('.\/tmp\/lossless_lossy.m'<\/span>))\r\n<\/pre>
\r\nans =\r\n\r\n     1\r\n\r\n<\/pre>
Yes.<\/p>
Let's switch to image formats. The PNG image format uses lossless compression. When you save image data to a PNG file, you can read the file back in and get back the original pixels, unchanged. For a sample image I'll use my imzoneplate function<\/a> on the MATLAB Central File Exchange.<\/p>
I = im2uint8(imzoneplate);\r\nimshow(I)\r\n<\/pre>\"\" 
Let's write I<\/tt> out to a PNG file, read it back in, and see if the pixels are the same.<\/p>
imwrite(I,'zoneplate.png'<\/span>);\r\nI2 = imread('zoneplate.png'<\/span>);\r\nisequal(I,I2)\r\n<\/pre>
\r\nans =\r\n\r\n     1\r\n\r\n<\/pre>
OK, now let's try the same experiment using JPEG.<\/p>
imwrite(I,'zoneplate.jpg'<\/span>)\r\nI2j = imread('zoneplate.jpg'<\/span>);\r\nisequal(I,I2j)\r\n<\/pre>
\r\nans =\r\n\r\n     0\r\n\r\n<\/pre>
No, the pixels are not equal! It turns out the JPEG is a lossy<\/i> image compression format. (Full disclosure: there is a lossless variant of JPEG, but it is rarely used.)<\/p>
Why in the world would we use a compression format that doesn't preserve the original data? Because by giving up on exact data recovery and by taking advantage of properties of human visual perception, we can make the stored file a lot smaller. Let's compare the file sizes of the PNG file with the JPEG file.<\/p>
z1 = dir('zoneplate.png'<\/span>);\r\nnum_bytes_png = z1.bytes\r\n<\/pre>
\r\nnum_bytes_png =\r\n\r\n      218864\r\n\r\n<\/pre>
z2 = dir('zoneplate.jpg'<\/span>);\r\nnum_bytes_jpeg = z2.bytes\r\n<\/pre>
\r\nnum_bytes_jpeg =\r\n\r\n       72660\r\n\r\n<\/pre>
The JPEG file is only one-third the size of the PNG file! But it looks almost exactly the same.<\/p>
imshow('zoneplate.jpg'<\/span>)\r\n<\/pre>\"\" 
So, what about that 'Quality'<\/tt> parameter that I mentioned at the top of today's post? It turns out that we can make the JPEG file even smaller if we are willing to put up with some visible distortion in the image. Let's try a quality factor of 25. (The default is 75 on a scale of 0 to 100.)<\/p>
imwrite(I,'zoneplate_25.jpg'<\/span>,'Quality'<\/span>,25)\r\nI2j_25 = imread('zoneplate_25.jpg'<\/span>);\r\nimshow(I2j_25)\r\n<\/pre>\"\" 
You can see some distortion, especially around the high-frequency part of the pattern. How about the file size?<\/p>
z3 = dir('zoneplate_25.jpg'<\/span>);\r\nz3.bytes\r\n<\/pre>
\r\nans =\r\n\r\n       39544\r\n\r\n<\/pre>
That's about 54% of the size of the zoneplate.jpg.<\/p>
Sometimes people think they can get \"lossless JPEG\" by using a 'Quality'<\/tt> factor of 100, but unfortunately that isn't the case. Let's check it:<\/p>
imwrite(I,'zoneplate_100.jpg'<\/span>,'Quality'<\/span>,100)\r\nI2j_100 = imread('zoneplate_100.jpg'<\/span>);\r\nisequal(I,I2j_100)\r\n<\/pre>
\r\nans =\r\n\r\n     0\r\n\r\n<\/pre>
So there you go -- that's why there's no 'Quality'<\/tt> parameter when writing PNG files. PNG files are always perfect!<\/p>
When I write blog posts, sometimes I use PNG image files and sometimes I use JPEG. My choice is based on what kind of graphics I have in that particular post. And that's a blog topic for another day.<\/p>