I'm playing around with a sketch that loads a jpg image, then saves it again as a jpg, then loads the saved jpg, and resaves it as a jpg etc. Why?! Well, I was curious to see how much information gets compressed in a lossy format when constantly resaving an image. I've seen that when iterating over the cycle the first time, there's a noticeable change in image quality - but after that the image filesize remains the same and there is no discernible difference between the 3rd and the 503rd image resaved.

So has the sun got to my brain and I've written an error into my code (which is likely), or can I not recompress the jpg more than once??? Or is here something more silly I haven't thought about (also quite likely)?  

Here's my code:
Code:

int openFile = 1; //name the source image as 1.jpg
int saveFile = 2;
int x, y=0;
PImage img;

void setup(){
  size(386, 600);//image size
}  

void draw(){
}

void mousePressed(){
  //can also paste the following code into draw for automation
  img = loadImage(openFile+".jpg");
  image(img, x, y, img.width, img.height);
  img.save(saveFile+".jpg");
  openFile = saveFile;
  saveFile = saveFile+1;

  print("opening"+openFile);
  print("   saving:");
  println(saveFile+"...done!");

  if (saveFile>1000){
    exit();
  }
}
 

The reason for this is because the second time around saving that same image, it has already gone through the quantization process and will perfectly compress again without loss of information.. all the cosine's match up...

Try randomly slightly changing the color of pixels here and there, which adds more information to the image.. then it will lose more of the original information with each save.

Jack

Yeah, it would be worse to adjust image saturation & save, than to make localized edits though because as guss mentioned, the format uses small squares to compress the image data, though I don't believe those squares could change size. My understanding was that they're always 8 by 8 pixels.

I know all this is outlined in tons of detail on wikipedia (http://en.wikipedia.org/wiki/JPEG#Encoding), but to shed a little more light on the process and refresh my own memory, here's a simplified explanation:

The image is first transformed into HSB color space (also known as Y Cb Cr), and downsampled into integer values allotting more bits for the brightness component. Then it's divided up into those 8 by 8 blocks, so you get nice localized arrays of 64 pixels per block.

These arrays are then fed through a discreet cosine transform, (one per channel I think) and you end up with 64 scalar values per channel of all the cosines that make up that 64 pixel block. This is the insane mathematics portion -- it can be the most difficult part to understand, but there are a ton of examples explaining how DCT's work online, and even code samples showing how they're written. The most advantageous thing about DCT's is the result is sorted from low to high frequency. This is nice because it makes it easy to choose the frequencies you think matter most for your compression, in this case it's the lower frequency information as it's what your eyes see more of at a distance.

Next, the result is fed through a low pass filter which is the big lossy component of the process. In this context it is called Quantization. All that really happens here is you divide the entire array by a scalar and round everything to integer values. This brings most of the high frequency information to 0 which you can throw away, and turns the low frequency information to small scalars that are easy to compress.

The last step is a combination of run-length encoding and huffman coding to compress those integer values. RLE & Huffman are both loss-less compression techniques.

It's really not all that difficult to write the algorithm as long as you use test-driven-development and build it one step at a time. And if one was going to attempt it, it's probably worth getting RLE and Huffman working first as those are a considerable amount of the work on thier own. =)

Wow, so yeah I'm like totally off topic but maybe I helped a couple people out with their coursework

Jack