使用 OpenCV 实现透明遮罩效果

import cv2
import numpy as np

# 加载图像并转换为 BGRA 格式
image = cv2.imread("face.jpg", cv2.IMREAD_UNCHANGED)
if image.shape[2] == 3:  # 如果是 BGR 图像，则转换为 BGRA
    image = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA)

# 创建空白的 BGRA 图像
width, height = 500, 500
bgra_image = np.zeros((height, width, 4), dtype=np.uint8)

import cv2
import numpy as np

# 加载前景图像和背景图像
foreground = cv2.imread("foreground.png", cv2.IMREAD_UNCHANGED)
background = cv2.imread("background.png")

# 确保背景图像和前景图像的尺寸相同
background = cv2.resize(background, (foreground.shape[1], foreground.shape[0]))

# 提取前景图像的 Alpha 通道
alpha = foreground[:, :, 3] / 255.0

# 将 Alpha 通道转换为三维数组
alpha = np.repeat(alpha[:, :, np.newaxis], 3, axis=2)

# 提取前景图像的颜色通道
foreground_rgb = foreground[:, :, :3].astype(float)

# 将背景图像转换为浮点数类型
background = background.astype(float)

# 进行 Alpha 混合
result = alpha * foreground_rgb + (1 - alpha) * background

# 将结果转换为 uint8 类型
result = result.astype(np.uint8)

# 显示结果
cv2.imshow("Result", result)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

# 创建一个简单的遮罩（例如，一个圆形）
mask = np.zeros((200, 200), dtype=np.uint8)
cv2.circle(mask, (100, 100), 50, 255, -1)

# 应用高斯模糊
blurred_mask = cv2.GaussianBlur(mask, (15, 15), 0)

# 创建一个 BGRA 图像，并将模糊后的遮罩作为 Alpha 通道
bgra_image = cv2.cvtColor(cv2.merge((mask,mask,mask, blurred_mask)), cv2.COLOR_RGB2BGRA)

# 显示结果
cv2.imshow("Blurred Mask", blurred_mask)
cv2.imshow("BGRA Image", bgra_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import time
import numpy as np
from OpenVtuber.TFLiteFaceDetector import UltraLightFaceDetecion
from OpenVtuber.TFLiteFaceAlignment import CoordinateAlignmentModel

lip_index = [52,55,56,53,59,58,61,68,67,71,63,64]
left_eye = [89,90,87,91,93,96,94,95]
right_eye = [39,42,40,41,35,36,33,37]

fd = UltraLightFaceDetecion("OpenVtuber\weights\RFB-320.tflite",conf_threshold=0.88)
fa = CoordinateAlignmentModel("OpenVtuber\weights\coor_2d106.tflite")

img = cv2.imread("face.jpg")

orange = cv2.imread('orange.png', cv2.IMREAD_UNCHANGED) # Load with alpha channel
if orange.shape[2] == 3:
    orange = cv2.cvtColor(orange, cv2.COLOR_BGR2BGRA)
orange = cv2.resize(orange,(160,221))

color = (0, 0, 255)

start_time = time.perf_counter()

def big_img(img,indexes):

    boxes, scores = fd.inference(img)
    for pred in fa.get_landmarks(img, boxes):
        landmarks = []
        for i in indexes:
            landmarks.append(pred[i])
        landmarks = np.array(landmarks,dtype=int)
        print(landmarks)

    x,y,w,h = cv2.boundingRect(landmarks)

    # Create a 4-channel mask (BGRA)
    mask = np.zeros((img.shape[0], img.shape[1], 4), dtype=np.uint8)
    cv2.drawContours(mask,[landmarks],-1,(255,255,255,255),-1) # Use 255 for alpha

    # Extract the ROI from the original image
    roi = img[y:y+h, x:x+w]

    # Resize the ROI
    result_big = cv2.resize(roi,(0,0),fx=4,fy=4)
    print(time.perf_counter() - start_time)

    return result_big

lip = big_img(img,lip_index)
lip = cv2.resize(lip,(75,28))

eye_r = big_img(img,right_eye)
eye_r = cv2.resize(eye_r,(45,19))

eye_l = big_img(img,left_eye)
eye_l = cv2.resize(eye_l,(45,20))

# masking 
mask = np.zeros([121, 100, 4], dtype=np.uint8) # Create a 4-channel mask
mask[0:19, 0:45 , 0:3] = eye_r[:,:,:3] # copy BGR channels
mask[0:19, 0:45 , 3] = 255 # set alpha to opaque

mask[0:20, 55:105,0:3] = eye_l[:,:,:3]
mask[0:20, 55:105,3] = 255

mask[46:74, 16:91,0:3] = lip[:,:,:3]
mask[46:74, 16:91,3] = 255

x, y, w, h = [60, 100, 106, 121]

# Extract the region of interest (ROI) from the orange image
roi = orange[y:y+h, x:x+w]

# Blend the mask with the ROI using alpha blending
alpha = mask[:, :, 3] / 255.0
for c in range(0, 3):
    orange[y:y+h, x:x+w, c] = (alpha * mask[:, :, c] +
                              (1 - alpha) * roi[:, :, c])

cv2.imwrite('result.png',orange)