import numpy as np
from PIL import Image
import pygetwindow as gw
import pyautogui
from flask import Flask, Response, render_template  # Импортировать render_template
import io

app = Flask(__name__)

# Укажите имя окна, которое вы хотите захватить
FIXED_WINDOW_TITLE = "BlueStacks App Player"  # Замените на имя вашего окна


def square_image(img):
    width, height = img.size
    if width != height:
        size = max(width, height)
        new_img = Image.new('RGB', (size, size), color=(0, 0, 0))
        new_img.paste(img, ((size - width) // 2, (size - height) // 2))
        return new_img
    else:
        return img


def capture_window(window_title):
    try:
        window = gw.getWindowsWithTitle(window_title)[0]
    except IndexError:
        return None

    x, y, width, height = window.left, window.top, window.width, window.height
    screenshot = pyautogui.screenshot()
    window_image = screenshot.crop((x, y, x + width, y + height))

    return window_image


def combine_images(original, copy):
    original_width, original_height = original.size
    copy_width, copy_height = copy.size

    combined_width = original_width + copy_width
    combined_height = max(original_height, copy_height)

    new_image = Image.new('RGB', (combined_width, combined_height), color=(0, 0, 0))

    new_image.paste(original, (0, (combined_height - original_height) // 2))
    new_image.paste(copy, (original_width - 100, (combined_height - copy_height) // 2))

    return new_image


@app.route('/')
def index():
    return render_template('index.html')  # Убедитесь, что ваш HTML-код сохранён в templates/index.html


@app.route('/video_feed')
def video_feed():
    def generate():
        while True:
            img = capture_window(FIXED_WINDOW_TITLE)
            if img is not None:
                img = square_image(img)
                img_copy = img.copy()
                combined_image = combine_images(img, img_copy)
                combined_image = combined_image.convert('RGB')

                img_byte_arr = io.BytesIO()
                combined_image.save(img_byte_arr, format='JPEG')
                frame = img_byte_arr.getvalue()

                yield (b'--frame\r\n'
                       b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')

    return Response(generate(),
                    mimetype='multipart/x-mixed-replace; boundary=frame')


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)


Как мне сделать чтобы вместо копированных изображений отображалось стереоизображение, вот пример кода который можно использовать
import cv2
import torch
import torchvision.transforms as tf
from PIL import Image
import numpy as np

# Проверка наличия GPU и установка устройства
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# Загружаем модель MiDaS
midas = torch.hub.load("isl-org/MiDaS", "MiDaS").to(device)
midas.eval()

# Преобразования входного изображения
transform = tf.Compose([
    tf.Resize((128, 128)),  # Уменьшение размера для повышения скорости
    tf.ToTensor(),
    tf.Normalize(mean=[0.5], std=[0.5]),
])

# Открываем видеопоток с камеры
cap = cv2.VideoCapture(0)

frame_count = 0

# Параметры для стереоизображения
stereo_disparity = 10  # Параметр смещения для создания стереоэффекта

while True:
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    if frame_count % 5 == 0:  # Обработка каждого 5-го кадра
        # Преобразование цвета и преобразование в PIL
        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        frame_pil = Image.fromarray(frame_rgb)

        # Преобразуем кадр
        input_tensor = transform(frame_pil).to(device)
        input_batch = input_tensor.unsqueeze(0)  # Добавление размерности для батча

        # Генерируем карту глубины
        with torch.no_grad():
            depth_map = midas(input_batch)

        # Преобразование карты глубины для отображения
        depth_map = depth_map.squeeze().cpu().numpy()
        depth_map = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min())  # Нормализация

        # Создание стереоизображений
        # Создаем смещение, нормализуем и преобразуем в 8-битное изображение
        depth_map_disp = (depth_map * stereo_disparity).astype(np.uint8)
        left_image = cv2.warpAffine(frame, np.float32([[1, 0, -stereo_disparity // 2], [0, 1, 0]]), (frame.shape[1], frame.shape[0]))
        right_image = cv2.warpAffine(frame, np.float32([[1, 0, stereo_disparity // 2], [0, 1, 0]]), (frame.shape[1], frame.shape[0]))

        # Отображение оригинального кадра, карты глубины и стереоизображений
        cv2.imshow("Frame", frame)
        cv2.imshow("Depth Map", (depth_map * 255).astype(np.uint8))  # Показываем глубину в 8-битах
        cv2.imshow("Left Image", left_image)
        cv2.imshow("Right Image", right_image)

    # Выход из цикла, если нажата клавиша 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()