To replace a part of image

import cv2
import numpy as np

img1 = cv2.imread('Desert.jpg')
img2 = cv2.imread('Penguins.jpg')

img3 = img1.copy()
# replace values at coordinates (100, 100) to (399, 399) of img3 with region of img2
img3[100:400,100:400,:] = img2[100:400,100:400,:]
cv2.imshow('Result1', img3)

To alpha blend two images

alpha = 0.5
img3 = np.uint8(img1*alpha + img2*(1-alpha))
cv2.imshow('Result2', img3)

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

What you are looking for is "over" compositing, and information about the algorithm I use for this can be found on Wikipedia: https://en.wikipedia.org/wiki/Alpha_compositing

This is the most efficient way I have found to accomplish the task:

import cv2

background = cv2.imread("background.png", cv2.IMREAD_UNCHANGED)
foreground = cv2.imread("overlay.png", cv2.IMREAD_UNCHANGED)

# normalize alpha channels from 0-255 to 0-1
alpha_background = background[:,:,3] / 255.0
alpha_foreground = foreground[:,:,3] / 255.0

# set adjusted colors
for color in range(0, 3):
    background[:,:,color] = alpha_foreground * foreground[:,:,color] + \
        alpha_background * background[:,:,color] * (1 - alpha_foreground)

# set adjusted alpha and denormalize back to 0-255
background[:,:,3] = (1 - (1 - alpha_foreground) * (1 - alpha_background)) * 255

# display the image
cv2.imshow("Composited image", background)
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:

Here is how you can use a simple mask:

import cv2

background = cv2.imread("background.png")
circle = cv2.imread("circle.png", cv2.IMREAD_UNCHANGED)

mask = circle[..., 3] != 0
background[mask] = circle[..., :3][mask]

cv2.imshow("Image", background)
cv2.waitKey(0)

Output:

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)

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

The format of the mask is strange for OpenCv to read on my system (using opencv 3.4.2). I was able to read it with cv2.IMREAD_UNCHANGED but it show me that your mask has 4 channels (I was expecting only one channel). The code below produce opposite or what you would expect:

 img = cv2.imread(r"C:\Users\...\Desktop\\W1kle.jpg")
 mask = cv2.imread(r"C:\Users\...\Desktop\LZdyB.png",cv2.IMREAD_UNCHANGED) 
 mask = mask[:,:,3]
 res = cv2.bitwise_and(img,img,mask=mask)
 cv2.imshow("image",res)
 cv2.waitKey(0)

Hope this helps you :)