devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

停车场无人值守管理系统_停车场管理系统

作者：花生_TL007 | 2024-02-23 04:48:10

赞

踩

停车场管理系统

停车场无人值守管理系统

（一）简介

该停车场无人系统是一种基于车牌识别的控制管理系统。系统通过识别车辆进出场时的车牌号码来确定车辆的进出许可,并确定车辆的停车时间和支付停车。车主可以选择自助支付机或者微信平台等方式支付停车费用。该系统主要由入口控制管理系统、出口控制管理系统和服务器中控系统组成。其实核心就是车牌识别和车辆数据的管理。这里用到的硬件是树莓派4b和云服务器，其实本来是不需要用到云服务器的，但是需要的一些第三方模块在树莓派上编译一直没有通过，所以具体的车牌号码的识别就交给了云服务来做了，树莓派负责一个车牌图片的采集，以及车牌号码的定位和车辆信息的管理系统服务。

（二）车牌定位

这里用到的是opencv-python内置的机器学习训练好的车牌识别器进行车牌识别（精度一般，但速度快），它会将识别到的车牌位置以数组的形式返回，但考虑到精度问题，只保留宽高比为2.7-3.3之间的车牌。然后将车牌部分的图像信息截取出来转为灰度图，送给服务器端的车牌识别模型进行预测，代码如下：


import time
import os
import cv2


cap = cv2.VideoCapture(0)  # 调用摄像头（一般电脑自带摄像头index为0）
numberPlates = cv2.CascadeClassifier("haarcascade_russian_plate_number.xml")


while True:
    while cap.isOpened():
        cat, frame = cap.read()  # 读取每一帧图片
        if not cat:
            # 判断是否读取到图片
            break

        # print(cap.get(3),cap.get(4))

        # 转换为灰度图片
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        gray = cv2.medianBlur(gray, 5)  # 中值滤波，这个中值滤波
        # img = cv2.GaussianBlur(gray, (3, 3), 0)  # 高斯滤波降噪处理
        # th1 = cv2.adaptiveThreshold(gray, 255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY, 17, 6) # 自适应二值化  # 自适应二值化处理
        # 车牌检测，1.2和2分别为图片缩放比例和需要检测的有效点数
        numberPlate = numberPlates.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=10)

        # 只有在检测到只有一个车牌时，才进入
        if len(numberPlate) == 1:
            x, y, w, h = numberPlate[0]  # numberPlate未检测到车牌是个元组，检测到车牌是个数组套数组
            ratio = w / float(h)
            if 2.7 < ratio < 3.3:  # 这里过滤一下
                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
                imgRoi = frame[y:y + h, x:x + w]
                imgRoi_gray = gray[y:y + h, x:x + w]
                # font = cv2.FONT_HERSHEY_SIMPLEX  # 创建摄像头前置的文字框
                # cv2.putText(frame, 'face', (x + 30, y + 30), font, 1, (255, 0, 255), 3)
                cv2.imshow("ROI", imgRoi)
                

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

这里将定位到的车牌号码的图片截取

（三）将车牌图片发送到云服务器端，并处理返回结果

这里将图片做base64转码发送到云服务器端，代码如下：

import requests
import json
import cv2
import base64


def cv2_to_base64(image):
    data = cv2.imencode('.jpg', image)[1]
    return base64.b64encode(data.tostring()).decode('utf8')

def send_target_gray(img):
    # 发送HTTP请求
    data = {'images': [cv2_to_base64(img)]}
    headers = {"Content-type": "application/json"}
    url = "http://ip:8866/predict/chinese_ocr_db_crnn_server"
    r = requests.post(url=url, headers=headers, data=json.dumps(data))

    return r.json()["results"]


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

返回的结果是json串，处理代码如下：

data_list = send_target_gray(imgRoi_gray)[0].get('data')  # 将roi区域送到服务器端进行预测
if data_list:
    data = data_list[0]  # 取置信度最大的结果
    text = data.get('text').replace(' ', '').replace('·', '').replace('-', '')  # 去除.-和前后可能产生的空格
    if len(text) == 7:  # 只有检测到的字符串长度为7（这里只检测一般的车牌）
        if text[0] in provinces:  # 只有第一个字符在省份列表里才继续
            print(text)
            if old_text:  # 如果有，则对比检测
                if old_text == text:  # 如果相等，则次数加一
                    detection_times = detection_times + 1
                    if detection_times >= 3:  # 连续三次相同，则跳出本次循环，进入大循环
                        if not Statistics.objects.filter(car_plate=text,
                                                         state=True).exists():  # 只有该车牌号不存在时，才创建
                            Statistics.objects.create(car_plate=text, state=True)

                            detection_times = 0
                            old_text = None
                            cv2.rectangle(frame, (140, 220), (530, 330), (0, 255, 0), cv2.FILLED)
                            cv2.putText(frame, "Scan Saved", (150, 300), cv2.FONT_HERSHEY_DUPLEX,
                                        2, (0, 0, 255), 2)
                            WillInNum.objects.filter(id=1).update(car_plate=text)
                            print('扫描成功')
                            cv2.imshow("frame", frame)
                            cv2.waitKey(5000)  # waitKey会阻塞程序
                            cv2.destroyWindow('frame')
                            cv2.destroyWindow('ROI')
                            WillInNum.objects.filter(id=1).update(car_plate='')
                            break
                else:  # 如果不相等，则清空次数和车牌号
                    detection_times = 0
                    old_text = None
            else:  # 如果没有，则将检测到车牌号赋值给old_text
                old_text = text

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

结果如图所示：
在这里插入图片描述

（四）服务器端的车牌号码识别模型

这里直接用到的是百度的paddlepaddle下的paddleocr，这里直接使用paddlehub提供预测的web服务，具体可参考
https://www.paddlepaddle.org.cn/hubdetail?name=chinese_ocr_db_crnn_server&en_category=TextRecognition，提供预测的方式有很多种，不局限于此。

（五）总的系统架构

该系统由三部分组成，入口控制管理系统，出口控制管理系统，服务器中控系统组成，具体结构如下图

在这里插入图片描述

（六）入口识别流程

在这里插入图片描述

import time

import django
import os
import cv2
from send import send_target_gray

# 设置django离线环境
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "graduation_design.settings")  # 加载项目的配置文件
django.setup()  # 启动django

from app01.models import Statistics,WillInNum
from graduation_design.settings import provinces

cap = cv2.VideoCapture(0)  # 调用摄像头（一般电脑自带摄像头index为0）
numberPlates = cv2.CascadeClassifier("haarcascade_russian_plate_number.xml")

old_text = None
detection_times = 0

while True:
    while cap.isOpened():
        cat, frame = cap.read()  # 读取每一帧图片
        if not cat:
            # 判断是否读取到图片
            break

        # print(cap.get(3),cap.get(4))

        # 转换为灰度图片
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        gray = cv2.medianBlur(gray, 5)  # 中值滤波，这个中值滤波
        # img = cv2.GaussianBlur(gray, (3, 3), 0)  # 高斯滤波降噪处理
        # th1 = cv2.adaptiveThreshold(gray, 255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY, 17, 6) # 自适应二值化  # 自适应二值化处理
        # 车牌检测，1.2和2分别为图片缩放比例和需要检测的有效点数
        numberPlate = numberPlates.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=10)

        # 只有在检测到只有一个车牌时，才进入
        if len(numberPlate) == 1:
            x, y, w, h = numberPlate[0]  # numberPlate未检测到车牌是个元组，检测到车牌是个数组套数组
            ratio = w / float(h)
            if 2.7 < ratio < 3.3:  # 这里过滤一下
                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
                imgRoi = frame[y:y + h, x:x + w]
                imgRoi_gray = gray[y:y + h, x:x + w]
                # font = cv2.FONT_HERSHEY_SIMPLEX  # 创建摄像头前置的文字框
                # cv2.putText(frame, 'face', (x + 30, y + 30), font, 1, (255, 0, 255), 3)
                cv2.imshow("ROI", imgRoi)
                data_list = send_target_gray(imgRoi_gray)[0].get('data')  # 将roi区域送到服务器端进行预测
                if data_list:
                    data = data_list[0]  # 取置信度最大的结果
                    text = data.get('text').replace(' ', '').replace('·', '').replace('-', '')  # 去除.-和前后可能产生的空格
                    if len(text) == 7:  # 只有检测到的字符串长度为7（这里只检测一般的车牌）
                        if text[0] in provinces:  # 只有第一个字符在省份列表里才继续
                            print(text)
                            if old_text:  # 如果有，则对比检测
                                if old_text == text:  # 如果相等，则次数加一
                                    detection_times = detection_times + 1
                                    if detection_times >= 3:  # 连续三次相同，则跳出本次循环，进入大循环
                                        if not Statistics.objects.filter(car_plate=text,
                                                                         state=True).exists():  # 只有该车牌号不存在时，才创建
                                            Statistics.objects.create(car_plate=text, state=True)

                                            detection_times = 0
                                            old_text = None
                                            cv2.rectangle(frame, (140, 220), (530, 330), (0, 255, 0), cv2.FILLED)
                                            cv2.putText(frame, "Scan Saved", (150, 300), cv2.FONT_HERSHEY_DUPLEX,
                                                        2, (0, 0, 255), 2)
                                            WillInNum.objects.filter(id=1).update(car_plate=text)
                                            print('扫描成功')
                                            cv2.imshow("frame", frame)
                                            cv2.waitKey(5000)  # waitKey会阻塞程序
                                            cv2.destroyWindow('frame')
                                            cv2.destroyWindow('ROI')
                                            WillInNum.objects.filter(id=1).update(car_plate='')
                                            break
                                else:  # 如果不相等，则清空次数和车牌号
                                    detection_times = 0
                                    old_text = None
                            else:  # 如果没有，则将检测到车牌号赋值给old_text
                                old_text = text
                time.sleep(0.5)
        # else:
        #     print('未检测到车辆')
        # cv2.flip(frame, 1, frame)

        cv2.imshow("in", frame)
        c = cv2.waitKey(10)
        if c & 0xFF == ord('q'):
            # 按q退出
            break
    print('进入了一辆车')


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93

（七）出口识别流程

在这里插入图片描述

import time
import django
import os
import cv2
from send import send_target_gray

# 设置django离线环境
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "graduation_design.settings")  # 加载项目的配置文件
django.setup()  # 启动django

from app01.models import Statistics, WillOutNum
from graduation_design.settings import provinces, locals_ip
from qr_code import code_generator

cap = cv2.VideoCapture(0)  # 调用摄像头（一般电脑自带摄像头index为0）
numberPlates = cv2.CascadeClassifier("haarcascade_russian_plate_number.xml")

old_text = None
detection_times = 0

while True:
    while cap.isOpened():
        cat, frame = cap.read()  # 读取每一帧图片
        if not cat:
            # 判断是否读取到图片
            break

        # 转换为灰度图片
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        gray = cv2.medianBlur(gray, 5)  # 中值滤波，这个中值滤波，小伙伴可以尝试将它去掉看看
        # img = cv2.GaussianBlur(gray, (3, 3), 0)  # 高斯滤波降噪处理,是不是感觉有图像处理的地方，就有高斯滤波
        # th1 = cv2.adaptiveThreshold(gray, 255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY, 17, 6) # 自适应二值化  # 自适应二值化处理
        # 车牌检测，1.2和2分别为图片缩放比例和需要检测的有效点数
        numberPlate = numberPlates.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=10)

        # 只有在检测到只有一个车牌时，才进入
        if len(numberPlate) == 1:
            x, y, w, h = numberPlate[0]  # numberPlate未检测到车牌是个元组，检测到车牌是个数组套数组
            ratio = w / float(h)
            if 2.7 < ratio < 3.3:  # 这里过滤一下
                cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 3)
                imgRoi = frame[y:y + h, x:x + w]
                imgRoi_gray = gray[y:y + h, x:x + w]
                # font = cv2.FONT_HERSHEY_SIMPLEX  # 创建摄像头前置的文字框
                # cv2.putText(frame, 'face', (x + 30, y + 30), font, 1, (255, 0, 255), 3)

                cv2.imshow("ROI", imgRoi)
                data_list = send_target_gray(imgRoi_gray)[0].get('data')
                if data_list:
                    data = data_list[0]  # 取置信度最大的结果
                    text = data.get('text').replace(' ', '').replace('·', '').replace('-', '')  # 去除.-和前后可能产生的空格
                    if len(text) == 7:
                        if text[0] in provinces:  # 只有第一个字符在省份列表里才继续
                            print(text)
                            if old_text:  # 如果有，则对比检测
                                if old_text == text:
                                    detection_times = detection_times + 1
                                    if detection_times >= 3:  # 连续三次相同，则跳出本次循环，进入大循环
                                        target_obj = Statistics.objects.filter(car_plate=text).first()
                                        if Statistics.objects.filter(car_plate=text, state=True):
                                            WillOutNum.objects.filter(id=1).update(car_plate=text)
                                            # 生成二维码
                                            code_generator(locals_ip, text)

                                            detection_times = 0
                                            old_text = None

                                            cv2.rectangle(frame, (140, 220), (530, 330), (0, 255, 0), cv2.FILLED)
                                            cv2.putText(frame, "Scan Saved", (150, 300), cv2.FONT_HERSHEY_DUPLEX,
                                                        2, (0, 0, 255), 2)

                                            print('扫描成功')
                                            cv2.imshow("frame", frame)
                                            cv2.waitKey(5000)  # waitKey会阻塞程序
                                            cv2.destroyWindow('frame')
                                            cv2.destroyWindow('ROI')
                                            break
                                else:  # 如果不相等，则清空次数和车牌号
                                    detection_times = 0
                                    old_text = None
                            else:  # 如果没有，则将检测到车牌号赋值给old_text
                                old_text = text

                time.sleep(0.5)
        # else:
        #     print('未检测到车辆')
        # cv2.flip(frame, 1, frame)
        cv2.imshow("out", frame)
        c = cv2.waitKey(10)
        if c & 0xFF == ord('q'):
            # 按q退出
            break


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93

（八）停车场管理系统

管理系统由web服务提供，先将web服务跑起来,命令如下：
python manage.py runserver 0.0.0.0:8000
然后在浏览器中输入：http://ip:8000/admin/，登录后台管理系统
用户登录界面
在这里插入图片描述
数据库结构预览
在这里插入图片描述
当入口扫描进入一辆车后，会在数据库中存入其信息
在这里插入图片描述
但车辆在出口识别到车牌号后，出口终端显示器，就会显示收款二维码，以及一些提示信息
在这里插入图片描述

微信扫码支付后，就会显示
在这里插入图片描述
停车场数据统计系统，数据就会显示如下数据，方便管理员查看
在这里插入图片描述

这里就不提供web服务的代码里，web服务就是django提供的，加入了websocket等，写的比较烂，虽然跑起来效果还不错

（九）结语

这里就简单的记录一下我的毕业设计，答辩时最有意思的事就是在答辩完后，导师告诉我让我准备二辩（补充一下：我们学校二辩往往就是一辩太差了，其实还有一种情况，就是一辩时是太优秀了，当我当时不知道这种情况），我心想不应该啊，答辩时，老师提的问题我都答出来了啊，然后导师跟我说，是你答辩的太优秀了，所以二辩，我当时还以为导师在嘲讽我（因为论文该格式时，被塔喷的不敢说话，没敢往好的方向想）。其实就这件事，我感觉就真的世事难料啊，就离谱，这TM就更你跑完了1km后，体育老师说，你跑的很好，在跑一遍一样

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/133784
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。