human/ui/pygame_ui.py

#encoding = utf8
import logging
import os
from queue import Queue

import cv2
import pygame
from pygame.locals import *

from human import HumanContext
from ipc import IPCUtil
from utils import config_logging, render_image

logger = logging.getLogger(__name__)
current_file_path = os.path.dirname(os.path.abspath(__file__))

ipc = IPCUtil('ipc_sender', 'ipc_sender')


def send_image(identifier, image):
    height, width, channels = image.shape

    width_bytes = width.to_bytes(4, byteorder='little')
    height_bytes = height.to_bytes(4, byteorder='little')
    bit_depth_bytes = channels.to_bytes(4, byteorder='little')

    img_bytes = image.tobytes()
    data = identifier + width_bytes + height_bytes + bit_depth_bytes + img_bytes
    ipc.send_binary(data, len(data))


def cal_box(inv_m, p):
    x = inv_m[0][0] * p[0] + inv_m[0][1] * p[1] + inv_m[0][2]
    y = inv_m[1][0] * p[0] + inv_m[1][1] * p[1] + inv_m[1][2]
    return x, y


class PyGameUI:
    def __init__(self):
        self._human_context = None
        self._queue = None
        self.screen_ = pygame.display.set_mode((920, 860), HWSURFACE | DOUBLEBUF | RESIZABLE)
        self.clock = pygame.time.Clock()

        background = os.path.join(current_file_path, '..', 'data', 'background', 'background.jpg')
        logger.info(f'background: {background}')
        self._background = pygame.image.load(background).convert()
        self.background_display_ = pygame.transform.scale(self._background, (920, 860))
        self._human_image = None
        self.running = True

    def start(self):
        self._queue = Queue()
        self._human_context = HumanContext()
        self._human_context.build()
        render = self._human_context.render_handler
        render.set_image_render(self)

    def run(self):
        self.start()
        while self.running:
            self.clock.tick(60)
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.running = False
                elif event.type == VIDEORESIZE:
                    self.background_display_ = pygame.transform.scale(self._background, event.dict['size'])
            self.screen_.blit(self.background_display_, (0, 0))
            self._update_human()
            if self._human_image is not None:
                self.screen_.blit(self._human_image, (0, -300))

            fps = self.clock.get_fps()
            pygame.display.set_caption('fps:{:.2f}'.format(fps))
            pygame.display.flip()
        self.stop()
        pygame.quit()

    def _update_human(self):
        if self._queue.empty():
            return

        if self._queue.qsize() > 5:
            print('render queue is slower')

        image = self._queue.get()
        image = render_image(self._human_context, image)
        color_format = "RGB"
        if 4 == image.shape[2]:
            color_format = "RGBA"
            image = cv2.cvtColor(image, cv2.COLOR_BGRA2RGBA)
        else:
            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        self._human_image = pygame.image.frombuffer(image.tobytes(), image.shape[1::-1], color_format)

    def stop(self):
        logger.info('stop')
        if self._human_context is not None:
            # self._human_context.pause_talk()
            self._human_context.stop()

    def on_render(self, image):
        self._queue.put(image)


if __name__ == '__main__':
    config_logging('../logs/info.log', logging.INFO, logging.INFO)

    logger.info('------------start------------')
    ui = PyGameUI()
    ui.run()
    logger.info('------------finish------------')