Actually the dst is created based on following formula:

dst = src1*alpha + src2*beta + gamma

Which says that when you multiply your images that are in fact 3D arrays with alpha you are multiplying all the items. For example, for a blue pixel you have [255, 0, 0] and the white [255, 255, 255], and when you are adding the matrices together, if you want the result to be blue you should convert the white pixels to 0 which is in fact black (doesn't make sense from physics perspective tho lol). You can simply find the white pixels using advanced numpy indexing then convert them to zero.

import cv2    

img1 = cv2.imread('img1.png')
img2 = cv2.imread('img2.png')

img1[img1[:, :, 1:].all(axis=-1)] = 0
img2[img2[:, :, 1:].all(axis=-1)] = 0

dst = cv2.addWeighted(img1, 1, img2, 1, 0)

cv2.imshow('sas', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

Result:

I found a example on github I modified a bit, works as expected:

import numpy as np
import cv2

img = cv2.imread('1_calib.jpeg')
overlay_t = cv2.imread('ol.png',-1) # -1 loads with transparency

def overlay_transparent(bg_img, img_to_overlay_t):
    # Extract the alpha mask of the RGBA image, convert to RGB 
    b,g,r,a = cv2.split(img_to_overlay_t)
    overlay_color = cv2.merge((b,g,r))

    mask = cv2.medianBlur(a,5)

    # Black-out the area behind the logo in our original ROI
    img1_bg = cv2.bitwise_and(bg_img.copy(),bg_img.copy(),mask = cv2.bitwise_not(mask))

    # Mask out the logo from the logo image.
    img2_fg = cv2.bitwise_and(overlay_color,overlay_color,mask = mask)

    # Update the original image with our new ROI
    bg_img = cv2.add(img1_bg, img2_fg)

    return bg_img

cv2.imshow('image',overlay_transparent(img, overlay_t))
cv2.waitKey(0)

Here is one way to do that in Python/Opencv.

• Read the transparent foreground image
• Read the background image
• Extract the alpha channel from the foreground image
• Extract the BGR channels from the foreground image
• Composite them together using np.where conditional
• Save the result

Front:

Back:

import cv2
import numpy as np

# read foreground image
img = cv2.imread('front.png', cv2.IMREAD_UNCHANGED)

# read background image
back = cv2.imread('back.png')

# extract alpha channel from foreground image as mask and make 3 channels
alpha = img[:,:,3]
alpha = cv2.merge([alpha,alpha,alpha])

# extract bgr channels from foreground image
front = img[:,:,0:3]

# blend the two images using the alpha channel as controlling mask
result = np.where(alpha==(0,0,0), back, front)

# save result
cv2.imwrite("front_back.png", result)

# show result
cv2.imshow("RESULT", result)
cv2.waitKey(0)

Result:

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.

If you want to overlay two images, simply use the OpenCV libraries.

[Sample]

Here is the sample python code using OpenCV to overlay image1 and image2

import cv2
import numpy as np

def overlay(image1, image2, x, y):
    image1_gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
    _, contours, _ = cv2.findContours(image1_gray, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    image1_mask = np.zeros_like(image1)
    cv2.drawContours(image1_mask, contours, -1, (255,255,255), -1)
    idx = np.where(image1_mask == 255)
    image2[y+idx[0], x+idx[1], idx[2]] = image1[idx[0], idx[1], idx[2]]
    return image2

if __name__ == '__main__':
    grass_img = cv2.imread('grassland.jpg')
    horse_img = cv2.imread('horse.png')
    overlayed = overlay(horse_img, grass_img, 300, 300)
    cv2.imwrite('overlayed.png', overlayed)

The result image was resized to reduce its volume, but in the above code, the resize code was omitted.

Result:

Update!

Here is the code using image's alpha value, and the output is better than before.

The idea is from overlay a smaller image on a larger image python OpenCv

def better_overlay(image1, image2, x, y):
    image1_alpha = image1[:, :, 3] / 255.0
    height, width = image1.shape[0], image1.shape[1]
    for c in range(3):
        image2[y:y+height, x:x+width, c] = image1_alpha * image1[:, :, c] + (1.0 - image1_alpha)* image2[y:y+height, x:x+width, c]
    return image2

Result:

I don't think that's possible. You'll have to create a new image or modify an existing one. Here's an article that shows how to do this: Transparent image overlays in OpenCV