Using @fireant's idea, I wrote up a function to handle overlays. This works well for any position argument (including negative positions).

def overlay_image_alpha(img, img_overlay, x, y, alpha_mask):
    """Overlay `img_overlay` onto `img` at (x, y) and blend using `alpha_mask`.

    `alpha_mask` must have same HxW as `img_overlay` and values in range [0, 1].
    """
    # Image ranges
    y1, y2 = max(0, y), min(img.shape[0], y + img_overlay.shape[0])
    x1, x2 = max(0, x), min(img.shape[1], x + img_overlay.shape[1])

    # Overlay ranges
    y1o, y2o = max(0, -y), min(img_overlay.shape[0], img.shape[0] - y)
    x1o, x2o = max(0, -x), min(img_overlay.shape[1], img.shape[1] - x)

    # Exit if nothing to do
    if y1 >= y2 or x1 >= x2 or y1o >= y2o or x1o >= x2o:
        return

    # Blend overlay within the determined ranges
    img_crop = img[y1:y2, x1:x2]
    img_overlay_crop = img_overlay[y1o:y2o, x1o:x2o]
    alpha = alpha_mask[y1o:y2o, x1o:x2o, np.newaxis]
    alpha_inv = 1.0 - alpha

    img_crop[:] = alpha * img_overlay_crop + alpha_inv * img_crop

Example usage:

import numpy as np
from PIL import Image

# Prepare inputs
x, y = 50, 0
img = np.array(Image.open("img_large.jpg"))
img_overlay_rgba = np.array(Image.open("img_small.png"))

# Perform blending
alpha_mask = img_overlay_rgba[:, :, 3] / 255.0
img_result = img[:, :, :3].copy()
img_overlay = img_overlay_rgba[:, :, :3]
overlay_image_alpha(img_result, img_overlay, x, y, alpha_mask)

# Save result
Image.fromarray(img_result).save("img_result.jpg")

Result:

If you encounter errors or unusual outputs, please ensure:

• img should not contain an alpha channel. (e.g. If it is RGBA, convert to RGB first.)
• img_overlay has the same number of channels as img.

I would guess that there's something off with your image. Let's look at the error returned

ValueError: could not broadcast input array from shape (0,0,3) into shape (150,165,3)

So eye appears to have the dimension (0,0,3) and img has the dimension (150,165,3). The 3 corresponds to RGB which is the 3 different color channels. So your original image is 150x165. But you tried to select a region at img[349:307, 410:383]. I suspect since the region you specified is outside the image it is not selecting anything hence the dimensions (0,0,3).

Try import pdb; pdb.set_trace() after the second line where you initialize eye. This will pop you into an interactive python terminal where you can see what's going on. Try to see what the dimensions of img are and if it's really what you want. Maybe the image you downloaded is smaller than the example causing the error.

Check out the first answer to a similar question. Your method for getting roi looks correct so try just adjusting the coordinates to a smaller region that fits.

If you use cv2, the correct method is to use the .copy() method in NumPy. It will create a copy of the array you need. Otherwise it will produce only a view of that object.

For example:

In [1]: import numpy as np

In [2]: x = np.arange(10*10).reshape((10, 10))

In [4]: y = x[3:7, 3:7].copy()

In [6]: y[2, 2] = 1000

In [8]: 1000 in x
Out[8]: False     # See, 1000 in y doesn't change values in x, the parent array.