Try using blend() instead of paste() - it seems paste() just replaces the original image with what you're pasting in.

try:
    from PIL import Image
except ImportError:
    import Image

background = Image.open("bg.png")
overlay = Image.open("ol.jpg")

background = background.convert("RGBA")
overlay = overlay.convert("RGBA")

new_img = Image.blend(background, overlay, 0.5)
new_img.save("new.png","PNG")

There are two issues:

• The math is incorrect:

subtracted_image = ImageChops.subtract(image2, image1)
==> subtracted_image = image2 - image1

reversed_image = ImageChops.add(image2, subtracted_image)
==> reversed_image = image2 + subtracted_image
==> reversed_image = image2 + (image2 - image1)
==> reversed_image = image2*2 - image1

As you can see the math is wrong.
The correct statement is:
reversed_image = ImageChops.add(image1, subtracted_image)
==> reversed_image = image1 + (image2 - image1)
==> reversed_image = image2

• The second issue is that ImageChops.subtract and ImageChops.add are not reversible operations.
  That is because the data type is uint8, and can't have negative values (and can't have values above 255).
  When using ImageChops.subtract, all negative values are clipped to zero.
  When using ImageChops.add, all values above 255 are clipped to 255.
  The clipping to range [0, 255] loses data, and we are not getting the original image.

There is a nice explanation in the following post.

We may use ImageChops.subtract_modulo and ImageChops.add_modulo, which are reversible.
The math is not intuitive, but it's working:

from PIL import Image, ImageChops

# Load the images
image1 = Image.open('image1.jpg')
image2 = Image.open('image2.jpg')

# Subtract image2 from image1
subtracted_image = ImageChops.subtract_modulo(image1, image2)  # image1 - image2

reversed_image = ImageChops.add_modulo(image2, subtracted_image)  # image2 + (image1 - image2)

# Display the reversed image
reversed_image.show() 

More intuitive solution is converting the images to NumPy arrays with type dtype np.int32 or np.int16.
Then subtract and add the NumPy arrays.
The advantage is that np.int32 or np.int16 types may hold positive and negative values, and have a larger range that avoids arithmetic overflow.

A solution upfront.

Background image

width/height/ratio: 300 / 375 / 0.800

Foreground image

width/height/ratio: 400 / 464 / 0.862

Overlay

from PIL import Image

imbg = Image.open("bg.png")
imfg = Image.open("fg.png")
imbg_width, imbg_height = imbg.size
imfg_resized = imfg.resize((imbg_width, imbg_height), Image.LANCZOS)
imbg.paste(imfg_resized, None, imfg_resized)
imbg.save("overlay.png")

Discussion

The most important information you have given in your question were:

• the aspect ratios of your foreground and background images are not equal, but similar
• the top left and bottom right corners of both images need to be aligned in the end.

The conclusion from these points is: the aspect ratio of one of the images has to change. This can be achieved with the resize() method (not with thumbnail(), as explained below). To summarize, the goal simply is:

Resize the image with larger dimensions (foreground image) to the exact dimensions of the smaller background image. That is, do not necessarily maintain the aspect ratio of the foreground image.

That is what the code above is doing.

Two comments on your approach:

First of all, I recommend using the newest release of Pillow (Pillow is the continuation project of PIL, it is API-compatible). In the 2.7 release they have largely improved the image re-scaling quality. The documentation can be found at http://pillow.readthedocs.org/en/latest/reference.

Then, you obviously need to take control of how the aspect ratio of both images evolves throughout your program. thumbnail(), for instance, does not alter the aspect ratio of the image, even if your size tuple does not have the same aspect ratio as the original image. Quote from the thumbnail() docs:

This method modifies the image to contain a thumbnail version of itself, no larger than the given size. This method calculates an appropriate thumbnail size to preserve the aspect of the image

So, I am not sure where you were going exactly with your (643,597) tuple and if you are possibly relying on the thumbnail to have this exact size afterwards.