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.

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")

In addition to hotels/restaurants, what do the maps show? Do they show the same features? My first attempt would be to rescale one map and then overlay the maps on each other using 50% opacity or something, but that may look really bad. If you can extract just the locations, you might be able to overlay then on OpenStreetMaps or some other common map so the combination looks consistent

thanks to @DanMašek hint and How to crop or remove white background from an image, I have worked out a solution. The following code will first remove white background from the smaller image, then set all images to 4 channels and then overlay the larger image with a smaller image. Works for me.

import cv2
import time
import math
import os
import numpy as np

pathSigns = "/home/moritz/Schreibtisch/Signs"
pathScenes = "/home/moritz/Schreibtisch/Scenes"
i = 0

for fSigns in os.listdir(pathSigns):
    fSigns = os.path.join(pathSigns, fSigns)
    s_img = cv2.imread(fSigns, -1)
    s_height, s_width, s_channels = s_img.shape

    # crop image
    gray = cv2.cvtColor(s_img, cv2.COLOR_BGR2GRAY)
    th, threshed = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)

    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11,11))
    morphed = cv2.morphologyEx(threshed, cv2.MORPH_CLOSE, kernel)

    _, cnts, _ = cv2.findContours(morphed, cv2.RETR_EXTERNAL, 
    cv2.CHAIN_APPROX_SIMPLE)
    cnt = sorted(cnts, key=cv2.contourArea)[-1]
    x,y,w,h = cv2.boundingRect(cnt)
    s_img = s_img[y:y+h, x:x+w]

    # set channels to 4
    if s_channels < 4:
        s_img = cv2.cvtColor(s_img, cv2.COLOR_BGR2BGRA)

    for fScenes in os.listdir(pathScenes):
        try:
            l_img = cv2.imread(os.path.join(pathScenes, fScenes))
            l_height, l_width, l_channels = l_img.shape

            if l_channels < 4:
                l_img = cv2.cvtColor(l_img, cv2.COLOR_BGR2BGRA)

            TARGET_PIXEL_AREA = (l_height * l_width) * 0.05

            ratio = float(s_img.shape[1]) / float(s_img.shape[0])
            s_new_h = int(math.sqrt(TARGET_PIXEL_AREA / ratio) + 0.5)
            s_new_w = int((s_new_h * ratio) + 0.5)

            s_img = cv2.resize(s_img,(s_new_w, s_new_h))

            x_offset=y_offset=50

            y1, y2 = y_offset, y_offset + s_img.shape[0]
            x1, x2 = x_offset, x_offset + s_img.shape[1]

            alpha_s = s_img[:, :, 3] / 255.0
            alpha_l = 1.0 - alpha_s

            for c in range(0, 3):
                l_img[y1:y2, x1:x2, c] = (alpha_s * s_img[:, :, c] + alpha_l * 
                 l_img[y1:y2, x1:x2, c])

            fResult = "/home/moritz/Schreibtisch/results/data_" + str(i) + ".png"
            i += 1
            cv2.imwrite(fResult, l_img)
        except IndexError:
            pass

A simple way to achieve what you want:

import cv2
s_img = cv2.imread("smaller_image.png")
l_img = cv2.imread("larger_image.jpg")
x_offset=y_offset=50
l_img[y_offset:y_offset+s_img.shape[0], x_offset:x_offset+s_img.shape[1]] = s_img

Update

I suppose you want to take care of the alpha channel too. Here is a quick and dirty way of doing so:

s_img = cv2.imread("smaller_image.png", -1)

y1, y2 = y_offset, y_offset + s_img.shape[0]
x1, x2 = x_offset, x_offset + s_img.shape[1]

alpha_s = s_img[:, :, 3] / 255.0
alpha_l = 1.0 - alpha_s

for c in range(0, 3):
    l_img[y1:y2, x1:x2, c] = (alpha_s * s_img[:, :, c] +
                              alpha_l * l_img[y1:y2, x1:x2, c])

There are two issues in the following line:

name = 'C:\Flare\flare_img'+str(fn[n])

1. In Python, special characters in strings are escaped with backslashes. Some examples are \n (newline), \t (tab), \f (form feed), etc. In your case, the \f is a special character that leads to a malformed path. One way to fix this is to use raw strings by adding an r before the first quote:

'C:\Flare\flare_img'
Out[12]: 'C:\\Flare\x0clare_img'

r'C:\Flare\flare_img'
Out[13]: 'C:\\Flare\\flare_img'

2. Do not just concatenate strings when you create filesystem paths. Sooner or later you end up misplacing a path separator. In this case, it is missing because fn[n] does not start with one. Let's say that fn[n] = "spam.png". Then assuming you do

name = r'C:\Flare\flare_img'+str(fn[n])

your value for name will be

C:\\Flare\\flare_imgspam.png

which is not what you intended.

Use os.path.join or the modern pathlib.Path as previously suggested. It is also redundant to wrap fn[n] in the str function because os.listdir already returns a list of strings.

The changes you need to make are as follows:

# add to imports section
from pathlib import Path

# add before for-loop
out_path = Path(r'C:\Flare\flare_img')

# change inside for-loop
name = out_path / fn[n]

Documentation: Python Strings

Homographies compose, so if you have the homographies between img1 and img2 and between img2 and img3 then the composition of those two homographies gives the homography between img1 and img3.

Your sizes are off of course because you're trying to match img3 to the stitched image containing img1 and img2. But you don't need to do that. Don't stitch them until you have all the homographies between each successive pair of images. Then you can proceed in one of two ways; work from the back or work from the front. I'll use for e.g. h31 to refer to the homography which warps img3 into coordinates of img1.

From the front (pseudocode):

warp img2 into coordinates of img1 with h21
warp img3 into coordinates of img1 with h31 = h32 @ h21
warp img4 into coordinates of img1 with h41 = h43 @ h31
...
stitch/blend images together

Here @ is the matrix multiplication operator, which will achieve our homography composition (note that it is safest to divide by the final entry in the homography to ensure that they're all scaled the same).

From the back (pseudocode):

...
warp prev stitched img into coordinates of img3 with h43
stitch warped stitched img with img3
warp prev stitched img into coordinates of img2 with h32
stitch warped stitched img with img2
warp prev stitched img into coordinates of img1 with h21
stitch warped stitched img with img1

The idea is either you start from the front, and warp everything into the first images coordinate frame, or start from the back, warp to the previous image and stitch, and then warp that stitched image into the previous image, and repeat. I think the first method is probably easier. In either case you have to worry about the propagation of errors in your homography estimation as they will build up over multiple composed homographies.

This is the naïve approach to blend multiple images together with just the homographies. The more sophisticated method is to use bundle adjustment, which takes into account feature points across all images. Then for good blending the steps are gain compensation to remove camera gain adjustments and vignetting, and then multi-band blending to prevent blurring. See the seminal paper from Brown and Lowe here and a brilliant example and free demo software here.