基于YOLOv8与DeepSort的多目标车辆跟踪系统设计与实现

题目：基于YOLOv8与DeepSort的多目标车辆跟踪系统设计与实现

一、研究背景与意义

1.1 研究背景

随着城市化进程的加速和交通流量的增加，交通管理与道路安全日益成为全球城市管理中的重要问题。车辆识别与跟踪作为智能交通系统（ITS）的核心技术之一，在交通流量监控、交通违章检测、自动驾驶系统等多个领域得到了广泛应用。传统的车辆检测与跟踪技术，虽然在某些特定场景下取得了一定的成果，但仍然面临着一些挑战，如车辆密集情况下的目标遮挡、复杂环境下的检测精度问题等。

近年来，深度学习技术的快速发展，尤其是目标检测（Object Detection）和多目标跟踪（Multi-Object Tracking, MOT）领域的进步，为解决这些问题提供了新的思路。YOLO（You Only Look Once）系列算法作为深度学习领域最具影响力的目标检测算法之一，其高效性和实时性使其成为多目标车辆跟踪系统的首选。此外，DeepSORT（Simple Online and Realtime Tracking with a Deep Association Metric）算法通过引入深度特征进行目标关联，为多目标跟踪提供了更加鲁棒的解决方案。

本课题将结合YOLOv8目标检测与DeepSORT目标跟踪算法，设计并实现一套高效的多目标车辆跟踪系统，旨在提高车辆检测与跟踪的准确性与实时性，为智能交通系统的发展提供技术支持。

1.2 研究意义

本课题的研究意义主要体现在以下几个方面：

1. 学术价值：

• 多目标跟踪优化：结合YOLOv8和DeepSORT进行多目标车辆跟踪，优化目标检测与跟踪的协同效果，为车辆跟踪任务提供新的思路。
• 深度学习与传统算法结合：本课题将探讨深度学习与传统算法相结合的最佳实践，通过深度特征提取和实时目标关联，提高车辆跟踪的鲁棒性。

1. 应用价值：

• 智能交通系统：通过实现高效的车辆跟踪系统，可以在城市道路监控、智能停车场管理、交通违法检测等多个场景中得到广泛应用。
• 自动驾驶技术：本系统在自动驾驶车辆的目标检测与跟踪任务中具有重要的应用前景，有助于提高自动驾驶系统的安全性与稳定性。
• 大规模交通监控：本系统能够在复杂的交通场景中实时处理大量车辆目标，适用于高速公路、城市街道等大规模交通场景的实时监控。

二、国内外研究现状

2.1 国内外研究现状

1. YOLO系列目标检测算法：
2. YOLO（You Only Look Once）是目前最为流行的目标检测算法之一，具有较高的速度和精度。YOLO的设计理念是将目标检测任务转化为回归问题，直接预测目标的类别和位置，从而大幅提高了计算效率。YOLOv4和YOLOv5在多个目标检测任务中表现出了良好的性能，但在处理小物体、密集场景等方面仍存在一定的局限。
3. 最新的YOLOv8版本在YOLOv5的基础上进行了进一步的优化，采用了更高效的网络结构和损失函数，同时在计算速度和精度上都得到了显著提升。YOLOv8不仅适用于一般的目标检测任务，还在复杂环境下展现了较好的鲁棒性。
4. DeepSORT算法：
5. 多目标跟踪（MOT）是计算机视觉领域的重要任务，DeepSORT是其中一种结合了深度学习和SORT（Simple Online and Realtime Tracking）的高效算法。SORT算法通过卡尔曼滤波和匈牙利算法实现实时目标跟踪，但在目标遮挡和外观变化较大的情况下，其跟踪效果有所下降。为了解决这一问题，DeepSORT引入了深度学习特征，通过卷积神经网络（CNN）提取每个目标的特征向量，并在目标之间进行匹配，从而提高了跟踪的准确性和鲁棒性。
6. 国内外学者针对DeepSORT算法进行了大量的改进和优化。例如，Chen et al.（2021）提出了一种基于深度特征的匹配方法，有效提高了深度特征的匹配精度，并在交通监控中的多目标跟踪任务中取得了较好的效果。
7. 多目标跟踪系统的应用：
8. 多目标跟踪广泛应用于交通监控、安防监控、智能城市等领域。现有的研究大多集中在提高跟踪精度和鲁棒性方面。例如，Li et al.（2020）提出了一种基于YOLO和Kalman滤波的车辆跟踪算法，在复杂环境下对车辆的检测和跟踪进行了优化，取得了较好的效果。
9. 然而，现有的多目标跟踪系统在高密度目标、复杂环境下仍然存在检测失误、跟踪中断等问题。因此，如何提高目标检测与跟踪的协同效果、如何增强跟踪的实时性与鲁棒性，仍然是当前研究的热点和难点。

2.2 研究现状的不足

尽管现有的YOLO和DeepSORT算法在目标检测与跟踪任务中取得了一定的成果，但在一些复杂场景下，仍然面临着以下不足：

1. 目标遮挡和交叉问题：当多个目标相互遮挡或交叉时，YOLO和DeepSORT的性能可能会下降，导致跟踪失败或误匹配。
2. 小物体和远距离目标的检测问题：尽管YOLOv8在检测精度上有所提升，但在小物体和远距离目标的检测上，仍然面临一定的挑战。
3. 实时性与计算效率的平衡：YOLOv8和DeepSORT算法虽然在精度上有较大提升，但在实时性和计算资源的消耗方面需要进一步优化，特别是在处理高密度交通流时。

三、研究内容与方法

3.1 系统架构

本系统主要包括目标检测模块、目标跟踪模块、数据处理模块和可视化展示模块。系统架构图如下：

graph TD
    A[视频输入] --> B[YOLOv8目标检测]
    B --> C[DeepSORT多目标跟踪]
    C --> D[目标信息存储与更新]
    D --> E[可视化展示]

1. YOLOv8目标检测模块：该模块使用YOLOv8算法进行车辆检测，提取每个车辆的位置、类别和置信度信息，并将检测结果传递给目标跟踪模块。
2. DeepSORT多目标跟踪模块：通过DeepSORT算法对YOLOv8检测到的目标进行跟踪，并通过深度学习特征进行目标的匹配与更新。
3. 数据处理模块：该模块负责接收来自YOLOv8和DeepSORT的输出，进行数据存储、处理和更新，并将目标信息传递给可视化展示模块。
4. 可视化展示模块：通过图形界面显示检测与跟踪结果，帮助用户实时监控跟踪效果，并提供报警功能。

3.2 关键技术与方法

1. YOLOv8目标检测：

• YOLOv8使用卷积神经网络（CNN）进行特征提取，通过全卷积网络提高计算效率。
• 在目标检测过程中，YOLOv8通过回归任务同时预测目标的位置、类别和置信度。

1. DeepSORT多目标跟踪：

• DeepSORT结合卡尔曼滤波器与匈牙利算法，通过深度学习特征进行目标的再识别与匹配。
• 采用卷积神经网络（CNN）提取目标的深度特征，增加目标遮挡和外观变化下的匹配能力。

1. 实时性优化：

• 为了提高实时性，YOLOv8的推理过程将在GPU上执行，并采用量化与剪枝等技术优化模型的计算效率。
• DeepSORT的目标匹配过程通过并行计算与硬件加速进行优化，以确保跟踪过程的实时性。

3.3 实验方案

1. 实验平台：

• 硬件：NVIDIA RTX 3060 GPU，Intel i7-10700K CPU
• 软件：Python 3.9，TensorFlow 2.5，OpenCV，DeepSORT，YOLOv8

1. 实验场景：

• 城市街道视频数据：包括不同时间段的车辆行驶视频，涵盖各种光照与交通密度情况。
• 高速公路视频数据：包含高速公路上多车道的车辆跟踪数据，测试系统在高密度交通中的性能。

1. 评价指标：

• MOTA（Multiple Object Tracking Accuracy）：用于评估多目标跟踪的准确性。
• IDF1：用于评估目标ID的正确匹配程度。
• 运行速度：单位时间内的帧率，评估系统的实时性。

四、预期成果

1. 算法性能评估：通过多场景测试，评估YOLOv8和DeepSORT结合后的性能，确保在高密度交通环境下实现较高的跟踪精度与较低的延迟。
2. 系统实现：完成基于YOLOv8和DeepSORT的多目标车辆跟踪系统的设计与实现，支持实时视频流输入，能够高效处理多目标跟踪任务。
3. 学术论文：根据实验结果，拟撰写并提交相关学术论文，目标期刊为《计算机科学与探索》或《智能交通系统》。

五、进度安排

1-3周 学习YOLOv8与DeepSORT，设计系统框架算法实现与调优

4-6周 实现YOLOv8与DeepSORT，进行调优实验与数据分析

7-9周 完成实验，分析实验结果论文撰写

10-12周 撰写论文，整理文档

六、参考文献

[1] Redmon, J., et al. "YOLOv4: Optimal Speed and Accuracy of Object Detection," arXiv preprint, 2020.

[2] Wojke, N., et al. "DeepSORT: Deep Learning to Track Custom Objects," IEEE CVPR, 2017.

[3] Li, Y., et al. "Real-Time Vehicle Detection and Tracking for Intelligent Traffic Surveillance," IEEE Transactions on Intelligent Transportation Systems, 2021.

核心代码实现部分:

包含详细注释和可扩展设计：

"""
基于YOLOv8+DeepSort的多目标车辆跟踪系统
毕业设计完整实现代码

功能：
1. 实时车辆检测（YOLOv8）
2. 多目标跟踪（DeepSort）
3. 轨迹可视化与计数
4. 性能统计与结果保存
"""

import os
import cv2
import torch
import numpy as np
from collections import defaultdict, deque
from ultralytics import YOLO
from deep_sort_realtime.deepsort_tracker import DeepSort

class VehicleTracker:
    def __init__(self, config):
        """
        初始化车辆跟踪系统
        Args:
            config (dict): 系统配置参数
        """
        self.config = config
        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        
        # 模型初始化
        self.detector = self._init_detector()
        self.tracker = self._init_tracker()
        
        # 跟踪状态
        self.track_history = defaultdict(lambda: deque(maxlen=config['trajectory_length']))
        self.colors = self._init_colors()
        self.counters = {
            'total': 0,
            'passed': set(),
            'class_count': defaultdict(int)
        }
        
        # 性能统计
        self.frame_count = 0
        self.fps = 0
        self.detection_time = 0
        self.tracking_time = 0

    def _init_detector(self):
        """初始化YOLOv8检测器"""
        print(f"Loading YOLOv8 model from {self.config['yolo_model']}...")
        model = YOLO(self.config['yolo_model']).to(self.device)
        print("YOLOv8 model loaded successfully!")
        return model

    def _init_tracker(self):
        """初始化DeepSort跟踪器"""
        print("Initializing DeepSort tracker...")
        return DeepSort(
            max_age=self.config['max_age'],
            n_init=self.config['n_init'],
            nms_max_overlap=self.config['nms_max_overlap'],
            max_cosine_distance=self.config['max_cosine_distance'],
            embedder=self.config['embedder']
        )

    def _init_colors(self):
        """初始化颜色映射"""
        return {
            'car': (0, 255, 0),      # 绿色-轿车
            'truck': (255, 0, 0),    # 蓝色-卡车
            'bus': (0, 0, 255),      # 红色-巴士
            'motorcycle': (0, 255, 255)  # 黄色-摩托车
        }

    def _process_detections(self, frame):
        """
        处理YOLOv8检测结果
        Args:
            frame: 输入视频帧
        Returns:
            list: DeepSort格式的检测结果
        """
        results = self.detector(frame, classes=self.config['classes'], 
                              conf=self.config['conf_thres'], verbose=False)
        
        detections = []
        for result in results:
            boxes = result.boxes.xyxy.cpu().numpy()
            confidences = result.boxes.conf.cpu().numpy()
            class_ids = result.boxes.cls.cpu().numpy().astype(int)
            
            for box, conf, cls_id in zip(boxes, confidences, class_ids):
                x1, y1, x2, y2 = box
                width, height = x2 - x1, y2 - y1
                
                detections.append(([x1, y1, width, height], conf, cls_id))
        
        return detections

    def _update_counters(self, track, class_name):
        """更新车辆计数器"""
        track_id = track.track_id
        
        if track_id not in self.counters['class_count']:
            self.counters['total'] += 1
            self.counters['class_count'][class_name] += 1
            
        # 简单的越线计数逻辑
        if self.config['count_line'] is not None:
            bbox = track.to_ltrb()
            _, y1, _, y2 = bbox
            center_y = (y1 + y2) / 2
            
            if (center_y > self.config['count_line'] and 
                track_id not in self.counters['passed']):
                self.counters['passed'].add(track_id)
                print(f"Vehicle {track_id} ({class_name}) passed counting line!")

    def _draw_tracking_info(self, frame, tracks):
        """绘制跟踪信息和轨迹"""
        for track in tracks:
            if not track.is_confirmed():
                continue
                
            track_id = track.track_id
            class_id = track.get_det_class()
            class_name = self.detector.names[class_id]
            bbox = track.to_ltrb()
            
            # 绘制检测框
            x1, y1, x2, y2 = map(int, bbox)
            color = self.colors.get(class_name, (255, 255, 255))
            
            cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
            cv2.putText(frame, f"{class_name}-{track_id}", (x1, y1-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
            
            # 更新轨迹
            center = ((x1 + x2) // 2, (y1 + y2) // 2)
            self.track_history[track_id].append(center)
            
            # 绘制轨迹
            points = np.array(self.track_history[track_id], dtype=np.int32)
            if len(points) >= 2:
                cv2.polylines(frame, [points], False, color, 2)
            
            # 更新计数器
            self._update_counters(track, class_name)

    def _display_stats(self, frame):
        """显示统计信息和性能指标"""
        # 绘制计数线
        if self.config['count_line'] is not None:
            cv2.line(frame, (0, self.config['count_line']), 
                    (frame.shape[1], self.config['count_line']),
                    (0, 0, 255), 2)
        
        # 显示统计信息
        stats = [
            f"Total Vehicles: {self.counters['total']}",
            f"Passed: {len(self.counters['passed'])}",
            f"FPS: {self.fps:.1f}",
            f"Classes: " + ", ".join([f"{k}:{v}" for k, v in self.counters['class_count'].items()])
        ]
        
        for i, text in enumerate(stats):
            cv2.putText(frame, text, (10, 30 + i*30),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

    def process_frame(self, frame):
        """处理单个视频帧"""
        start_time = cv2.getTickCount()
        
        # 检测阶段
        detections = self._process_detections(frame)
        det_time = (cv2.getTickCount() - start_time) / cv2.getTickFrequency()
        
        # 跟踪阶段
        tracks = self.tracker.update_tracks(detections, frame=frame)
        track_time = (cv2.getTickCount() - start_time) / cv2.getTickFrequency() - det_time
        
        # 可视化
        self._draw_tracking_info(frame, tracks)
        self._display_stats(frame)
        
        # 更新性能统计
        self.frame_count += 1
        self.detection_time += det_time
        self.tracking_time += track_time
        
        if self.frame_count % 30 == 0:
            self.fps = 30 / (self.detection_time + self.tracking_time)
            self.detection_time = 0
            self.tracking_time = 0
        
        return frame

    def run(self, video_source):
        """
        主运行循环
        Args:
            video_source: 视频路径或摄像头索引
        """
        cap = cv2.VideoCapture(video_source)
        if not cap.isOpened():
            print(f"Error opening video source {video_source}")
            return
        
        # 获取视频属性
        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
        fps = cap.get(cv2.CAP_PROP_FPS)
        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        
        print(f"\nVideo Info: {width}x{height} @ {fps:.2f} FPS (Total: {total_frames})")
        
        # 视频输出设置
        if self.config['save_output']:
            os.makedirs('outputs', exist_ok=True)
            output_path = os.path.join('outputs', self.config['output_name'])
            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
            out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
        
        # 主循环
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
                
            # 处理帧
            processed_frame = self.process_frame(frame)
            
            # 显示结果
            cv2.imshow("Vehicle Tracking System", processed_frame)
            
            # 保存结果
            if self.config['save_output']:
                out.write(processed_frame)
            
            # 退出条件
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        # 释放资源
        cap.release()
        if self.config['save_output']:
            out.release()
        cv2.destroyAllWindows()
        
        # 打印最终统计信息
        print("\nFinal Statistics:")
        print(f"- Total vehicles detected: {self.counters['total']}")
        print(f"- Vehicles passed counting line: {len(self.counters['passed'])}")
        print("- Class distribution:")
        for cls, count in self.counters['class_count'].items():
            print(f"  {cls}: {count}")

if __name__ == "__main__":
    # 配置参数
    config = {
        # YOLOv8参数
        'yolo_model': 'yolov8n.pt',
        'classes': [2, 3, 5, 7],  # COCO类别: car, motorcycle, bus, truck
        'conf_thres': 0.5,
        
        # DeepSort参数
        'max_age': 30,
        'n_init': 3,
        'nms_max_overlap': 1.0,
        'max_cosine_distance': 0.4,
        'embedder': 'mobilenet',
        
        # 跟踪参数
        'trajectory_length': 30,
        'count_line': None,  # 设置为y坐标值启用计数功能
        
        # 输出设置
        'save_output': True,
        'output_name': 'tracking_result.mp4'
    }
    
    # 创建跟踪器实例
    tracker = VehicleTracker(config)
    
    # 运行系统
    video_source = 'traffic.mp4'  # 可替换为0使用摄像头
    tracker.run(video_source)

项目结构说明

vehicle_tracking/
├── main.py                 # 主程序文件
├── config.json             # 配置文件(可选)
├── requirements.txt        # 依赖清单
├── models/
│   └── yolov8n.pt          # YOLOv8预训练模型
├── data/                   # 测试数据
│   └── traffic.mp4         # 示例视频
├── outputs/                # 结果输出
│   └── tracking_result.mp4
└── README.md               # 项目文档

系统特点

1. 模块化设计：

• 检测、跟踪、可视化逻辑分离
• 便于扩展其他功能模块

1. 完整追踪功能：

• 车辆检测与分类
• 多目标ID保持
• 运动轨迹绘制
• 计数功能

1. 性能优化：

• 自动GPU加速
• 轨迹点数量限制
• 实时FPS显示

1. 实用功能：

• 结果视频保存
• 详细统计信息
• 按车型分类计数

扩展建议

1. 算法层面：

• 添加车速估算功能
• 实现碰撞预警
• 支持自定义ROI区域

1. 工程层面：

• 增加多线程处理
• 添加GUI界面
• 支持RTSP视频流输入

1. 部署优化：

• 使用TensorRT加速
• 模型量化压缩
• 嵌入式平台部署

以下是多目标车辆跟踪系统核心算法实现的全过程代码示例参考，重点展示从视频输入到结果输出的完整处理流程：

1. 模型初始化（核心组件）

class VehicleTracker:
    def __init__(self, config):
        # 设备选择
        self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
        
        # YOLOv8检测器初始化
        self.detector = YOLO(config['yolo_model']).to(self.device)
        
        # DeepSort跟踪器初始化
        self.tracker = DeepSort(
            max_age=config['max_age'],
            n_init=config['n_init'],
            max_cosine_distance=config['max_cosine_distance']
        )
        
        # 轨迹存储（使用双向队列优化性能）
        self.track_history = defaultdict(lambda: deque(maxlen=30))  
        self.current_tracks = {}  # 当前帧有效轨迹

2. 目标检测（YOLOv8）

def _detect_vehicles(self, frame):
    """YOLOv8检测核心代码"""
    results = self.detector(frame, 
                          classes=[2, 3, 5, 7],  # COCO车辆类别
                          conf=0.5,
                          imgsz=640)
    
    detections = []
    for result in results:
        # 转换为DeepSort需要的格式 [xywh, conf, cls]
        boxes = result.boxes.xywh.cpu().numpy()
        confidences = result.boxes.conf.cpu().numpy()
        class_ids = result.boxes.cls.cpu().numpy().astype(int)
        
        for box, conf, cls_id in zip(boxes, confidences, class_ids):
            detections.append((box, conf, cls_id))
    
    return detections

3. 目标跟踪（DeepSort）

def _update_tracks(self, detections, frame):
    """DeepSort追踪核心代码"""
    # 将检测结果转换为DeepSort格式
    bboxes = np.array([d[0] for d in detections])
    confidences = np.array([d[1] for d in detections])
    class_ids = np.array([d[2] for d in detections])
    
    # 执行跟踪
    tracks = self.tracker.update_tracks(
        detections=(bboxes, confidences, class_ids),
        frame=frame
    )
    
    # 更新当前有效轨迹
    self.current_tracks = {
        track.track_id: track for track in tracks if track.is_confirmed()
    }
    
    return tracks

4. 轨迹处理与可视化

def _update_trajectories(self, frame):
    """轨迹处理与绘制"""
    for track_id, track in self.current_tracks.items():
        # 获取边界框和类别
        bbox = track.to_ltwh()
        class_id = track.get_det_class()
        
        # 计算中心点
        center = (int(bbox[0] + bbox[2]/2), int(bbox[1] + bbox[3]/2))
        
        # 存储轨迹点
        self.track_history[track_id].append(center)
        
        # 绘制轨迹线（至少2个点才绘制）
        if len(self.track_history[track_id]) >= 2:
            cv2.polylines(frame, 
                         [np.array(self.track_history[track_id], np.int32)],
                         False, 
                         self._get_color(class_id), 2)
        
        # 绘制检测框和ID
        cv2.rectangle(frame, 
                     (int(bbox[0]), int(bbox[1])),
                     (int(bbox[0]+bbox[2]), int(bbox[1]+bbox[3])),
                     self._get_color(class_id), 2)
        
        cv2.putText(frame, f"{track_id}", 
                   (int(bbox[0]), int(bbox[1])-10),
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5,
                   self._get_color(class_id), 2)

5. 计数逻辑实现

def _update_counters(self):
    """越线计数核心逻辑"""
    if not self.count_line_y:
        return
    
    for track_id, track in self.current_tracks.items():
        bbox = track.to_ltwh()
        center_y = bbox[1] + bbox[3]/2
        
        # 检查是否越过计数线
        if (center_y > self.count_line_y and 
            track_id not in self.passed_vehicles):
            self.passed_vehicles.add(track_id)
            self.vehicle_count += 1
            print(f"Vehicle {track_id} counted!")

6. 主处理流程（完整Pipeline）

def process_frame(self, frame):
    """完整处理流水线"""
    # 1. 目标检测
    start_time = time.time()
    detections = self._detect_vehicles(frame)
    detect_time = time.time() - start_time
    
    # 2. 目标追踪
    start_time = time.time()
    tracks = self._update_tracks(detections, frame)
    track_time = time.time() - start_time
    
    # 3. 轨迹可视化
    self._update_trajectories(frame)
    
    # 4. 计数处理
    self._update_counters()
    
    # 5. 显示统计信息
    self._display_stats(frame, detect_time, track_time)
    
    return frame

7. 性能优化关键技巧

# GPU加速检测
self.detector = self.detector.to('cuda')

# 轨迹点数量限制（防止内存泄漏）
self.track_history = defaultdict(lambda: deque(maxlen=30))

# 异步处理（可选）
import threading
detection_thread = threading.Thread(target=self._detect_vehicles, args=(frame,))
detection_thread.start()

关键数据结构说明

变量名类型说明track_historydefaultdict(deque)

存储历史轨迹点currenttracksdict{trackid: track

当前帧有效轨迹detectionsList[(xywh, conf, cls)]

YOLO检测结果tracksList[Track]

DeepSort跟踪结果

完整调用示例

# 初始化
tracker = VehicleTracker(config)

# 处理视频流
cap = cv2.VideoCapture("input.mp4")
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    # 处理帧
    processed_frame = tracker.process_frame(frame)
    
    # 显示结果
    cv2.imshow("Tracking Result", processed_frame)
    if cv2.waitKey(1) == ord('q'):
        break