Tryag File Manager

//paip/script/lpr/detectron2_LPR/lpr_rest_api.py

import subprocess
import time
import os, sys
import detectron2_lpd_inference
import cnn_lpr_inference
import recog_demo
# import detectron2_lpr_inference
import flask
from flask import request, jsonify
from flask_cors import CORS
from dateutil.parser import parse
from collections import deque, Counter
import pandas as pd
import uuid
import matplotlib.pyplot as plt
from datetime import datetime
import cv2
from PIL import ImageFont, ImageDraw, Image
import numpy as np
import shutil
import asyncio
from multiprocessing import Pool
from threading import Thread

# set sys path to import PyDBconnector
HOME_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir)
# HOME_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)))
MODULE_DIR = 'util'
sys.path.append(os.path.join(HOME_PATH, MODULE_DIR))
from PyDBconnector import PyDBconnector
from logs import paiplog

data_queue = deque()
lpr_dict = {"image_time" : 0, "lpr_result" : 0}
last_time = 0

@paiplog
def compare_word(lpr_result, lpr_type) :
    print("---------비 교 -----------")
    for lpr_data in lpr_result :
        print(lpr_data)
    print("-------------------------")

# 1. 번호판 글자 갯수가 7에서 9까지 범위인 것만 뽑기
    lpr_result = [lpr_result[i] for i in range(len(lpr_result)) if (len(lpr_result[i]) >= 7) and (len(lpr_result[i]) <= 9)]

# 2. 번호판 적합성 체크
    lpr_result = [lpr_result[i] for i in range(len(lpr_result)) if lpr_result[i][-5] not in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]]

if len(lpr_result) == 0 :
        data_queue.clear()
        print(" [Error] --------------> Queue License Plate is Empty !!")
        return False, None

print(lpr_result)

# 3. 최빈 글자수인 것만 찾기
    count_list = []
    for lpr_element in lpr_result:
        count_list.append(len(lpr_element))

most_count = Counter(count_list).most_common()[0][0]
    lpr_type_result = max(set(lpr_type), key=lpr_type.count)
    lpr_result = [lpr_result[i] for i in range(len(lpr_result)) if (len(lpr_result[i]) == most_count)]

# 4. 한자씩 비교하여 최빈 글자 찾기

df = pd.DataFrame(lpr_result).T

final_lpr_result = []
    word = []
    for j in range(0, most_count):
        for i in range(0, len(df.columns)):
            #print(df[i][0][j])
            word.append(df[i][0][j])
        max_num = max(set(word), key=word.count)
        final_lpr_result.append(max_num)
        word = []

result = "".join(final_lpr_result)
    print("=================================")
    print("최종 번호판 = ", result, "번호판 종류 = ", lpr_type_result)
    print("=================================")

return result, lpr_type_result

def upload_db(start_time, end_time, lpr_result, license_plate_type, farm_id):

dbConn = PyDBconnector()

# 개발 DB Insert
    tid = str(uuid.uuid4()).split('-')[-1]
    now_date = datetime.today().strftime('%Y-%m-%d %H:%M:%S')
    now_date = pd.to_datetime(now_date)

if farm_id is None:
        insert_str = f"insert into tbl_lpr (TID, CREATE_TIME, START_TIME, END_TIME, LPR_RESULT, TYPE) values('{tid}', '{now_date}', '{start_time}', '{end_time}', '{lpr_result}', '{license_plate_type}')"
    else:
        insert_str = f"insert into tbl_farm_statistic_lpr (TID, CREATE_TIME, FARM_ID, START_TIME, END_TIME, LPR_RESULT, TYPE) values('{tid}', '{now_date}', '{farm_id}', '{start_time}', '{end_time}', '{lpr_result}', '{license_plate_type}')"
    
    try :
        dbConn.insert_to_db(insert_str)
        print("DB upload Success")
        dbConn.close()
    except Exception as e :
        print(e)
        dbConn.close()

async def countdown(num_of_secs):
    last_time = lpr_dict["image_time"]

while True:
        if len(data_queue) == 0 :
            break
        time.sleep(1)
        num_of_secs -= 1
        #print("sec : ", num_of_secs, "      ", last_time, "--------", data_queue[-1]["image_time"])
        if last_time != data_queue[-1]["image_time"] :
            print("break loop-----")
            break

if num_of_secs == 0 :
            if last_time == data_queue[-1]["image_time"]:

lpr_list = []
                for lpr_data in data_queue:
                    lpr_list.append(lpr_data['lpr_result'])

lpr_type_list = []
                for lpr_type in data_queue:
                    lpr_type_list.append(lpr_type['license_plate_type'])

result, lpr_type = compare_word(lpr_list, lpr_type_list)
                if result == False :
                    break
                else :
                    # DB 값 전송하면 됨
                    print("Time over ---------> Auto Update data")
                    upload_db(data_queue[0]["image_time"], data_queue[-1]["image_time"], result, lpr_type, data_queue[0]["farm_id"])
                    # data_dict = {'CREATE_TIME': now_date, 'START_TIME': data_queue[0]["image_time"],
                    #              'END_TIME': data_queue[-1]["image_time"], "LPR_RESULT": result}

data_queue.clear()

if num_of_secs < 0:
            break

#print('Countdown finished.')

def queue_process():

while True :
        time.sleep(1)

if len(data_queue) == 0 :
            continue

if len(data_queue) > 1:
            last_queue_data = data_queue[-1]

date_diff = (data_queue[-1]["image_time"] - data_queue[0]["image_time"]).seconds
            #print("초 차이 :", date_diff)

lpr_list = []
            for lpr_data in data_queue:
                lpr_list.append(lpr_data['lpr_result'])

lpr_type_list = []
            for lpr_type in data_queue :
                lpr_type_list.append(lpr_type['license_plate_type'])

# 이미지 시간 차이가 10 이상일 때 전송
            if date_diff >= 10:
                result, lpr_type = compare_word(lpr_list[:-1], lpr_type_list[:-1])
                if result == False:
                    pass
                else:
                    # DB 값 전송하면 됨
                    # data_dict = {'CREATE_TIME': now_date, 'START_TIME': data_queue[0]["image_time"],
                    #              'END_TIME': data_queue[-1]["image_time"], "LPR_RESULT": result}
                    upload_db(data_queue[0]["image_time"], data_queue[-2]["image_time"], result, lpr_type, data_queue[0]["farm_id"])
                    data_queue.clear()
                    data_queue.append(last_queue_data)

asyncio.run(countdown(30))

app = flask.Flask(__name__)
app.config['JSON_AS_ASCII'] = False
CORS(app)

def on_json_loading_failed_return_dict(e):
    print(e)
    return {
        'except' : e,
        'status': "fail"
    }

@app.route("/api/lpr_result", methods=["POST"])
def result_request():
    # api_time = datetime.today().strftime('%Y-%m-%d %H:%M:%S')
    # api_time = pd.to_datetime(api_time)

request.on_json_loading_failed = on_json_loading_failed_return_dict
    start_time = time.time()
    image_reponse = request.get_json('dir')
    image_dir = image_reponse['dir']
    image_name = image_reponse['image_name']

if image_name.find(".jpg") == -1:
        image_name = image_name + '.jpg'

if image_dir[-1] != "/" :
        image_dir = image_dir + "/"

image_time = ''
    farm_id = None
    if 'FA' in image_name:
        #image_name : FA0001_GW01_H01_CT01_20240104225039473_farm_image_real_b65b229946ce.jpg
        image_time = parse(image_name.split("_")[4][:-3])
        farm_id = image_name.split("_")[0]
    else :
        #image_name : 192.100.0.181_01_20231122092019080_LINE_CROSSING_DETECTION.jpg
        image_time = parse(image_name.split("_")[2][:-3])

print('농장 ID : ', farm_id)
    print('날짜 및 시간 : ', image_time)
    print('파일 경로 : ', image_dir)
    print('이미지 이름 :', image_name)

# detection = detectron2_lpd_inference.LicensePlate_Detector.getInstance()
    # recognition = detectron2_lpr_inference.LicensePlate_Recognition.getInstance()
    # recog = recog_demo.Recognition.getInstance()

try:
        # Detection
        start = time.time()
        lpd_result, out_img, license_plate_type, mx, my, mx2, my2 = detection.Predict_LPD(image_dir, image_name, farm_id)
        end = time.time()
        print("번호 Detection 시간 : " + f"{end - start:.5f} sec" + f"번호판 종류 : {license_plate_type}줄 번호판",)

# Recognition
        start1 = time.time()
        lpr_result = recognition.Predict_LPR(lpd_result, license_plate_type)
        lpr_result = lpr_result[0]
        end1 = time.time()
        print("번호 Recog 시간 : " + f"{end1 - start1:.5f} sec   번호 결과 : {lpr_result}")

response = {
            "image_name": image_name,
            "lpr_result" : lpr_result,
            "status": "success",
        }
        ###########################
        # 이미지 저장

out_img_copy = out_img.get_image()[:, :, ::-1].copy()
        # img = np.full(shape=(512, 512, 3), fill_value=255, dtype=np.uint8)
        img = Image.fromarray(out_img_copy)
        draw = ImageDraw.Draw(img)
        font = ImageFont.truetype("/usr/share/fonts/nhn-nanum/NanumGothicExtraBold.ttf", 40, encoding="UTF-8")
        org = (50, 100)
        draw.text(org, lpr_result, font=font, fill=(0, 0, 0))
        out_img_put_text =np.array(img)

#numpy_img = np.array(out_img_put_text).copy()
        #cv_img = cv2.cvtColor(numpy_img, cv2.COLOR_RGB2BGR)

# out_img_puttext = cv2.putText(img, lpr_result, (350, 40), cv2.FONT_HERSHEY_PLAIN, 2, (0, 0, 0), 1, cv2.LINE_4)
        size, BaseLine = cv2.getTextSize(lpr_result, cv2.FONT_HERSHEY_SIMPLEX, 2, 4)
        cv2.rectangle(out_img_put_text, org, (org[0] + size[0], org[1] + size[1]), (0, 0, 0))
        cv2.circle(out_img_put_text, org, 3, (255, 0, 255), 2)

#roi
        cv2.rectangle(out_img_put_text, (mx,my), (mx2, my2), (0,255,255), 4)

jpg_index = image_name.rfind('.jpg')
        plt_image = image_name[0:jpg_index] + "_lprDetectionResult.jpg"
        plt_dir = image_dir + 'result'

try :
            os.makedirs(plt_dir)
        except OSError:
            if not os.path.isdir(plt_dir) :
                raise

save_dir = plt_dir + '/' + plt_image
        # print("------=============----------")
        # print(image_dir + image_name)
        # print(plt_dir + "/" + image_name)

# 원본 이미지 복사
        shutil.copyfile(image_dir + image_name, plt_dir + "/" + image_name)

# result 이미지 저장
        plt.imsave(save_dir, out_img_put_text)

temp_dict = {"image_time" : image_time, "lpr_result" : lpr_result, "license_plate_type" : license_plate_type, "farm_id" : farm_id}
        data_queue.append(temp_dict)
        #print(data_queue)
        lpr_dict['image_time'] = image_time
        lpr_dict['lpr_result'] = lpr_result

except Exception as e:
        print(e)
        response = {
            "image_name": image_name,
            "status": "fail",
        }

end_time = time.time()
    print(f"<<<< detect_result finish {end_time - start_time:.5f} sec >>>>")

return jsonify(response)

if __name__ == '__main__':
    print('-------------------- LPR model loading ---------------------')

detection = detectron2_lpd_inference.LicensePlate_Detector.getInstance()
    # recognition = detectron2_lpr_inference.LicensePlate_Recognition.getInstance()
    recognition = cnn_lpr_inference.LicensePlate_Recognition.getInstance()

#dbConn = PyDBconnector()

t1 = Thread(target=queue_process)
    t1.daemon = True
    t1.start()
    app.run(host="0.0.0.0", port=8891)