Show transparent image with openCV python

Question

im working with opencv and when showing the image it has a black background even its already transparent, (sometimes white) but that depends on the image, in this case the eye image when showing it appears with black background, dont know how can i show it complety transparent:

while True:

    recording, frame = video.read();

    rgba = cv2.cvtColor(frame, cv2.COLOR_BGR2BGRA);

    eye.drawEyes(rgba, frame_width, frame_height);
  
    cv2.imshow("Mediapipe", rgba);

    if cv2.waitKey(1) & 0xFF == ord('q'): 
        break

video.release();

cv2.destroyAllWindows();

and here the class Eye where i call the method to draw the eyes:

class Eye:

    MP_FACE = mp.solutions.face_mesh;
    FACE = MP_FACE.FaceMesh();
 
    LEFT_EYE = [226, 173]; #468 CENTER LANDMARK
    RIGHT_EYE = [398, 446];

    EYE_IMAGE = cv2.imread("./assets/eye.png", cv2.IMREAD_UNCHANGED);
    RESIZE_EYE = cv2.resize(EYE_IMAGE, (80, 80), interpolation = cv2.INTER_AREA)  # `int(height)` for 2nd value of size
    
    def __init__(self):
        self: self
        self.eye_left_x = 0;
        self.eye_left_y = 0;
        self.eye_left_x2 = 0;
        self.eye_left_y2 = 0;

        self.eye_right_x = 0;
        self.eye_right_y = 0
        self.eye_right_x2 = 0;
        self.eye_right_y2 = 0;

        self.centerX = 0;
        self.centerY = 0;
    
        self.image = "";
    
    def drawEyes(self, frame, frame_width, frame_height):

        face_points = self.FACE.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB));

        rectangle_height = 30;
               
        if (face_points):
            for landmark in face_points.multi_face_landmarks:
                for index, points in enumerate(landmark.landmark):

                    if (index == self.LEFT_EYE[0]):
                        x, y = int(points.x * frame_width), int(points.y * frame_height);
                        self.eye_left_x = x;
                        self.eye_left_y = y;
                 
                    if (index == self.LEFT_EYE[1]):
                        x, y = int(points.x * frame_width), int(points.y * frame_height);
                        self.eye_left_x2 = x;
                        self.eye_left_y2 = y;
                
                    if (index == self.RIGHT_EYE[0]):
                        x, y = int(points.x * frame_width), int(points.y * frame_height);
                        self.eye_right_x = x;
                        self.eye_right_y = y;
                     
                    if (index == self.RIGHT_EYE[1]):
                        x, y = int(points.x * frame_width), int(points.y * frame_height);
                        self.eye_right_x2 = x;
                        self.eye_right_y2 = y;
                     
                    cv2.rectangle(
                        frame, 
                        (self.eye_left_x, self.eye_left_y - rectangle_height), 
                        (self.eye_left_x2, self.eye_left_y2 + rectangle_height),
                        (0,255,255), 
                        1
                    );

                    cv2.rectangle(
                        frame, 
                        (self.eye_right_x, self.eye_right_y - rectangle_height), 
                        (self.eye_right_x2, self.eye_right_y2 + rectangle_height),
                        (0,255,255), 
                        1
                    );

                    rectangle_width_left = self.eye_left_x2 - self.eye_left_x;
                    rectangle_width_right = self.eye_right_x2 - self.eye_right_x;

                    eye_width = hypot(self.eye_left_x - self.eye_left_x2, self.eye_left_y - self.eye_left_y2);
                    eye_height = eye_width * 1; #1 = aspect ratio, height image / width image
        
        image = cv2.resize(self.EYE_IMAGE, (int(eye_width), int(eye_height)), interpolation = cv2.INTER_AREA);

        h, w = image.shape[:2];

        # left eye
        x, y = self.eye_left_x, self.eye_left_y;
        centerX = (rectangle_width_left - int(w)) // 2;
        frame[y-rectangle_height : y + int(w) - rectangle_height, x+centerX : x + centerX+int(w), :] = image
     
        # right eye
        x2, y2 = self.eye_right_x, self.eye_right_y;
        centerX = (rectangle_width_right - int(w)) // 2;
        frame[y2-rectangle_height : y2 + int(w) - rectangle_height, x2+centerX : x2 + centerX+int(w)] = image
     

this is my code now, i print the frame and it has 4 channel, same with the image, but still dont know how to show it complety transparent, dont understand and dont know how to work with the mask that looks is the case to use here.

some help will be appreciate

Answer 1

cv2.imshow() doesn't handle transparency, it's only really a quick debugging feature rather than a full-fat viewer. You'd need to use wx, Qt, or Tk, or some other proper framework.