I don't want a red mask over human on output

from PIL import Image, ImageDraw, ImageFont
import numpy as np
import mediapipe as mp
import cv2

def inject_speech_bubble_in_the_background(input_image_path, text=None, shape='oval', line='handdrawn', font_path=None):
    if not text:
        return input_image_path

    # Open and convert the image to RGBA
    image = input_image_path
    draw = ImageDraw.Draw(image)
    
    # Load MediaPipe segmentation model
    mp_selfie_segmentation = mp.solutions.selfie_segmentation
    with mp_selfie_segmentation.SelfieSegmentation(model_selection=1) as segmenter:
        img_np = np.array(image)
        results = segmenter.process(cv2.cvtColor(img_np, cv2.COLOR_RGBA2BGR))
        
        # Find bounding boxes of segments
        character_bounding_box = find_character_bounding_box(results.segmentation_mask, image.width, image.height)
        
    # Split text into bubbles and calculate locations
    bubbles = split_text_into_bubbles(text)
    bubble_locations = calculate_bubble_locations(len(bubbles), image.width, image.height, character_bounding_box)

    # Draw the speech bubbles
    for i, bubble_text in enumerate(bubbles):
        bubble_location = bubble_locations[i]
        draw_speech_bubble(draw, bubble_location, bubble_text, shape, line, font_path, character_bounding_box, image.width, image.height)

    return image

def find_character_bounding_box(mask, width, height):
    shapes = []
    visited = set()
    mask = np.array(mask).astype(np.uint8)

    def flood_fill(x, y):
        queue = [(x, y)]
        min_x, max_x, min_y, max_y = x, x, y, y
        while queue:
            cx, cy = queue.pop(0)
            if (cx < 0 or cx >= width or cy < 0 or cy >= height or mask[cy, cx] == 0 or (cy, cx) in visited):
                continue
            visited.add((cy, cx))
            min_x, max_x = min(min_x, cx), max(max_x, cx)
            min_y, max_y = min(min_y, cy), max(max_y, cy)
            queue.extend([(cx+1, cy), (cx-1, cy), (cx, cy+1), (cx, cy-1)])
        return min_x, min_y, max_x - min_x + 1, max_y - min_y + 1

    for y in range(height):
        for x in range(width):
            if mask[y, x] > 0 and (y, x) not in visited:
                shape = flood_fill(x, y)
                if shape[2] * shape[3] > width * height * 0.01:
                    shapes.append(shape)

    if shapes:
        shapes = sorted(shapes, key=lambda s: s[2] * s[3], reverse=True)
        most_vertical_shape = max(shapes, key=lambda s: s[3] / s[2])
        return most_vertical_shape
    return None

def split_text_into_bubbles(text):
    import re
    pattern = r'(?:[A-Z][a-z]*\.\s*)*(?:[^.!?\s]+[^.!?]*[.!?]+)|\S+'
    matches = re.findall(pattern, text)
    return [match.strip() for match in matches]

def calculate_bubble_locations(bubble_count, image_width, image_height, character_bounding_box):
    locations = []
    padding = 50
    available_width = image_width - padding * 2
    available_height = image_height - padding * 2
    max_attempts = 100
    
    for i in range(bubble_count):
        attempts = 0
        while attempts < max_attempts:
            if character_bounding_box:
                character_middle = character_bounding_box[0] + character_bounding_box[2] / 2
                left_side = np.random.rand() * (character_middle - padding - padding)
                right_side = character_middle + np.random.rand() * (image_width - character_middle - padding - padding)
                x = np.random.rand() < 0.5 and left_side or right_side
            else:
                x = np.random.rand() * available_width + padding
            y = (i / bubble_count) * available_height + padding
            if not character_bounding_box or not is_overlapping((x, y), character_bounding_box):
                locations.append((x, y))
                break
            attempts += 1
        if attempts >= max_attempts:
            print(f'Warning: Could not find non-overlapping position for bubble {i} after {max_attempts} attempts.')
    return locations

def is_overlapping(point, box):
    px, py = point
    bx, by, bw, bh = box
    return px >= bx and px <= bx + bw and py >= by and py <= by + bh

def draw_speech_bubble(draw, location, text, shape, line, font_path, character_bounding_box, image_width, image_height, safety_margin=0.1):
    padding = 24
    border_padding = max(10, min(image_width, image_height) * safety_margin)
    font_size = 20
    font = ImageFont.truetype(font_path, font_size) if font_path else ImageFont.load_default()

    # Wrap text
    max_bubble_width = min(image_width - 2 * border_padding, image_width * 0.33)
    wrapped_text = wrap_text(draw, text, max_bubble_width - padding * 2, font_size)
    text_dimensions = measure_text_dimensions(draw, wrapped_text, font_size)

    final_width = min(max(text_dimensions[0] + padding * 2, 100), max_bubble_width)
    final_height = min(max(text_dimensions[1] + padding * 2, 50), image_height - 2 * border_padding)
    
    bubble_location = adjust_bubble_location(location, final_width, final_height, character_bounding_box, image_width, image_height, border_padding)

    tail_target = None
    if character_bounding_box:
        tail_target = (character_bounding_box[0] + character_bounding_box[2] / 2, character_bounding_box[1] + character_bounding_box[3] * 0.3)

    # Draw bubble
    draw.rectangle([bubble_location[0] - final_width / 2, bubble_location[1] - final_height / 2,
                    bubble_location[0] + final_width / 2, bubble_location[1] + final_height / 2], fill='white', outline='black')

    # Draw the tail if necessary
    if tail_target:
        draw_tail(draw, bubble_location, final_width, final_height, tail_target, shape)

    # Draw the text
    text_location = (bubble_location[0], bubble_location[1])
    draw.text(text_location, wrapped_text, font=font, fill='black', anchor='mm')

def wrap_text(draw, text, max_width, font_size):
    lines = []
    words = text.split()
    line = ''
    for word in words:
        test_line = f'{line} {word}'.strip()
        text_width, text_height = draw.textsize(test_line, font=ImageFont.truetype("arial.ttf", font_size))
        if text_width <= max_width:
            line = test_line
        else:
            lines.append(line)
            line = word
    if line:
        lines.append(line)
    return '\n'.join(lines)

def measure_text_dimensions(draw, text, font_size):
    width, height = 0, 0
    for line in text.split('\n'):
        line_width, line_height = draw.textsize(line, font=ImageFont.truetype("arial.ttf", font_size))
        width = max(width, line_width)
        height += line_height
    return width, height

def adjust_bubble_location(location, width, height, character_bounding_box, image_width, image_height, border_padding):
    x, y = location
    x = min(max(x, border_padding + width / 2), image_width - border_padding - width / 2)
    y = min(max(y, border_padding + height / 2), image_height - border_padding - height / 2)
    return x, y

def draw_tail(draw, bubble_location, bubble_width, bubble_height, target, shape):
    tail_size = 20
    tx, ty = target
    bx, by = bubble_location
    bx1, by1 = bx - bubble_width / 2, by - bubble_height / 2

    if shape == 'handdrawn':
        draw.line([bx, by, tx, ty], fill='black', width=2)
        draw.polygon([(tx, ty), (tx - tail_size, ty - tail_size), (tx + tail_size, ty - tail_size)], fill='white', outline='black')

    # Add more shapes if needed (e.g., 'oval', 'rect', etc.)

# Example usage
output_image = inject_speech_bubble_in_the_background(images[0], text="Hello world! This is a test message.", shape='oval', line='handdrawn', font_path='arial.ttf')
output_image.show()