问题[очередь]

我有一个图像显示队列。我从队列中取出一张图像，显示它，等待两秒钟，然后拍摄下一张。但是，队列充满了来自外部的事件，因此可以在处理其他项目时将项目添加到其中。在我的代码中，调用 ShowImage() 方法会创建一个并行循环，因此图像不会延迟。我怎么解决这个问题？

// Метод вызывается по событию.
private void AddImageToSchedule(int imgNumber)
 {
     switch (imgNumber)
     {
     case 1:
         _schedule.Enqueue(_images[ImagesNames.FirstBlood]);
         break;

     case 2:
         _schedule.Enqueue(_images[ImagesNames.DoubleKill]);
         break;

     case 3:
         _schedule.Enqueue(_images[ImagesNames.TripleKill]);
         break;

     case 4:
         _schedule.Enqueue(_images[ImagesNames.UltraKill]);
         break;

     case 5:
         _schedule.Enqueue(_images[ImagesNames.Riot]);
         break;
 }
 
 ShowImage();
}

private async void ShowImage()
{
 while (_schedule.Count != 0)
 {
     var img = _schedule.Dequeue();
     _ui.ShowImage(img);
     await Task.Delay(SHOW_TIME);
 }
}

我正在尝试在单独的线程中从相机录制视频而不加载主进程。为此，我实现了 Recorder 类，但它并不总是有效。有时视频坏了，有时程序只是“起床”。我认为错误在连接中的某个地方，但我不能完全理解

# recorder.py

import queue
import threading
from typing import Tuple

import cv2


class Recorder(threading.Thread):
    def __init__(self, output_path: str,
                 fourcc: str = 'mp4v',
                 fps: float = 30,
                 resolution: Tuple[int, int] = (1920, 1080),
                 record_in_background: bool = True):
        super(Recorder, self).__init__(daemon=record_in_background)

        self.resolution = resolution

        self.writer = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*fourcc),
                                      fps, self.resolution)

        self.frames_queue = queue.Queue()

        self.recording = False

    def __del__(self):
        self.frames_queue.join()

        self.writer.release()

    def write(self, frame):
        self.frames_queue.put(frame)

    def start(self):
        super().start()
        return self

    def run(self):
        self.recording = True
        while self.recording or not self.frames_queue.empty():
            frame = self.frames_queue.get()

            resized_frame = cv2.resize(frame, self.resolution)

            self.writer.write(resized_frame)

            self.frames_queue.task_done()

    def stop(self):
        self.recording = False

        self.join()

# main.py

import cv2

import recoder

cam = cv2.VideoCapture(0)
r = recoder.Recorder("123.mp4", resolution=(640, 480))
r.start()

while True:
    ret, frame = cam.read()

    if not ret:
        break

    r.write(frame)

    cv2.imshow("frame", frame)
    cv2.waitKey(1)

    if cv2.waitKey(25) == ord('q'):
        break

cv2.destroyAllWindows()
cam.release()
r.stop()

创建基于以下的队列类型Seq：

import Data.Sequence

type Queue v = Seq v

现在我想编写一个返回队列第一个元素（“头”）的函数。从我阅读和谷歌搜索的所有内容看来，应该是这样的：

qhead :: Queue v -> v
qhead Empty = error "empty sequence"
qhead (x :<| xs) = x

赛皮特：

不在范围内：数据构造函数 ':<|'

好的，我是这样做的：

qhead' :: ViewL v -> v
qhead' EmptyL = error "empty sequence"
qhead' (x :< xs) = x

qhead :: Queue v -> v
qhead q = qhead' $ viewl q

但也许可以做一些更笨拙的事情？直接用typeQueue来比较，不介意一些笨蛋ViewL吗？还是这么犹太？

完整代码：

import Data.Sequence

type Queue v = Seq v

qhead' :: ViewL v -> v
qhead' EmptyL = error "empty sequence"
qhead' (x :< xs) = x

qhead :: Queue v -> v
qhead q = qhead' $ viewl q

{-
*R.QTree> qhead $ fromList [12,13,14,15]
12
-}

标准列表 ( [a]) 允许您在列表末尾快速插入并从列表末尾快速删除。

假设我们可以push为它创建一个“类似列表”的类型和一个函数，以保持“快速”添加的第一个元素可用，以便我们可以有效地循环从最旧到最新的队列：

data Queue a = Empty | Element a (Queue a)

push :: a -> Queue a -> Queue a
push a Empty             = Element a Empty
push a (Value b pointer) = Element b (push a pointer)

但是有一个明显的缺点——添加一个新元素时，它会递归地“深入”到队列中，即随着队列的增长，新添加的速度会越来越慢。

本质上，这是一个问题——如何在 Haskell 中实现一个容器FIFO，以便您可以快速添加一个新元素并快速从中读取，从旧元素开始？