|
|
@@ -0,0 +1,935 @@
|
|
|
+# �� by Ultralytics, AGPL-3.0 license
|
|
|
+"""
|
|
|
+Run YOLOv5 detection inference on images, videos, directories, globs, YouTube, webcam, streams, etc.
|
|
|
+Usage - sources:
|
|
|
+ $ python detect.py --weights yolov5s.pt --source 0 # webcam
|
|
|
+ img.jpg # image
|
|
|
+ vid.mp4 # video
|
|
|
+ screen # screenshot
|
|
|
+ path/ # directory
|
|
|
+ list.txt # list of images
|
|
|
+ list.streams # list of streams
|
|
|
+ 'path/*.jpg' # glob
|
|
|
+ 'https://youtu.be/Zgi9g1ksQHc' # YouTube
|
|
|
+ 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream
|
|
|
+Usage - formats:
|
|
|
+ $ python detect.py --weights yolov5s.pt # PyTorch
|
|
|
+ yolov5s.torchscript # TorchScript
|
|
|
+ yolov5s.onnx # ONNX Runtime or OpenCV DNN with --dnn
|
|
|
+ yolov5s_openvino_model # OpenVINO
|
|
|
+ yolov5s.engine # TensorRT
|
|
|
+ yolov5s.mlmodel # CoreML (macOS-only)
|
|
|
+ yolov5s_saved_model # TensorFlow SavedModel
|
|
|
+ yolov5s.pb # TensorFlow GraphDef
|
|
|
+ yolov5s.tflite # TensorFlow Lite
|
|
|
+ yolov5s_edgetpu.tflite # TensorFlow Edge TPU
|
|
|
+ yolov5s_paddle_model # PaddlePaddle
|
|
|
+"""
|
|
|
+import matplotlib.path as mat
|
|
|
+import requests
|
|
|
+import argparse
|
|
|
+import os
|
|
|
+import platform
|
|
|
+import sqlite3
|
|
|
+import sys
|
|
|
+import threading
|
|
|
+import time
|
|
|
+from pathlib import Path
|
|
|
+import signal
|
|
|
+import torch
|
|
|
+from concurrent.futures import ThreadPoolExecutor
|
|
|
+from concurrent.futures import ProcessPoolExecutor
|
|
|
+from multiprocessing import Process, Manager, Value
|
|
|
+from multiprocessing import Queue
|
|
|
+from multiprocessing import set_start_method
|
|
|
+import multiprocessing
|
|
|
+import multiprocessing as mp
|
|
|
+import numpy as np
|
|
|
+from torchvision import transforms
|
|
|
+import random
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+FILE = Path(__file__).resolve()
|
|
|
+ROOT = FILE.parents[0] # YOLOv5 root directory
|
|
|
+if str(ROOT) not in sys.path:
|
|
|
+ sys.path.append(str(ROOT)) # add ROOT to PATH
|
|
|
+ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
|
|
|
+from models.common import DetectMultiBackend
|
|
|
+from utils.dataloaders import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreams, LoadStreamsSQLNEWN, LoadStreamsSQL, \
|
|
|
+ LoadStreamsSQLNRERT, LoadStreamsVEight, LoadStreamsSQLT, LoadStreamsSQLTNP,preprocess
|
|
|
+from utils.general import (LOGGER, Profile, check_file, check_img_size, check_imshow, check_requirements, colorstr, cv2,
|
|
|
+ increment_path, non_max_suppression, print_args, scale_boxes, strip_optimizer, xyxy2xywh,
|
|
|
+ strtolst, apply_classifier1, apply_classifieruniform, compute_IOU, task, apply_classifierarm,numpy_image_to_base64)
|
|
|
+from utils.plots import Annotator, colors, save_one_box
|
|
|
+from utils.torch_utils import select_device, smart_inference_mode
|
|
|
+from utils.renwu import newHelmet, newUniform, newFall, Personcount, Arm, Bag, Cross, Extinguisher, newPersontre, Bag, Danager,CarHelmetBelt,Clear
|
|
|
+from loguru import logger
|
|
|
+# from testpool import func1,TestA
|
|
|
+# def my_handler(signum, frame):
|
|
|
+# exit(0)
|
|
|
+# url = "http://36.7.84.146:18802/ai-service/open/api/operate/upload"
|
|
|
+url = "http://172.19.152.231/open/api/operate/upload"
|
|
|
+urlrtsp = "http://172.19.152.231/open/api/operate/previewURLs"
|
|
|
+urlt = "http://172.19.152.231/open/api/operate/taskList"
|
|
|
+urla = "http://172.19.152.231/open/api/operate/algorithmList"
|
|
|
+urlele = "http://172.19.152.231/open/api/operate/fence"
|
|
|
+urltime = "http://172.19.152.231/open/api/operate/getTime"
|
|
|
+urlperson = "http://172.19.152.231/open/api/operate/getPersonLimitNum"
|
|
|
+urlque = "http://172.19.152.231:8001/analyze/"
|
|
|
+questiondir = {
|
|
|
+ "uniform":"图片中的所有人都穿工作服了吗，请回答是或否",
|
|
|
+ "fall":"图片中的人摔倒了吗，请回答是或否",
|
|
|
+ "persontre":"图片中的人坐踩手推车了吗，请回答是或否",
|
|
|
+ "helmet":"图片中的人戴工作帽了吗，清回答是或否"
|
|
|
+ }
|
|
|
+
|
|
|
+# modellabeldir = {'0':'head','8':'person','10':'other','14':'smoke','16':'fire','21':'cross','25':'fall','29':'car','30':'liquid','31':'pressure','32':'sleep','33':'conveyor','34':'personcount','35':'gloves','36':'sit','37':'other','38':'person','98':'face','51':'person'}
|
|
|
+# algmodel = {'helmet': '0','danager': '8','uniform': '10','smoke': '14','fire': '16','cross': '21','fall': '25','occupancy': '29','liquid': '30','pressure': '31','sleep': '32','conveyor': '33','personcount': '34','gloves': '35','sit': '36','other': '37','duty': '38','face': '98','run': '51'}
|
|
|
+modelnamedir = {'0': 'helmet', '8': 'danager', '10': 'uniform', '14': 'smoke', '16': 'fire', '21': 'cross',
|
|
|
+ '25': 'fall', '29': 'occupancy', '30': 'liquid', '31': 'pressure', '32': 'sleep', '34': 'personcount',
|
|
|
+ '37': 'other', '38': 'duty', '98': 'face', '55': 'oil', '52': 'jingdian', '53': 'rope',
|
|
|
+ '54': 'personcar', '39': 'inspection', '11': 'reflective', '12': 'phone', '66': 'extinguisher',
|
|
|
+ '67': 'belt', '68': 'menjin', '35': 'arm', '36': 'persontre', '33': 'bag','62':'clear'}
|
|
|
+modellabeldir = {'0': 'head,person', '8': 'person', '10': 'black_work_clothes,blue_work_clothes,person', '14': 'smoke',
|
|
|
+ '16': 'fire', '21': 'cross', '25': 'fall', '29': 'car', '30': 'liquid', '31': 'pressure',
|
|
|
+ '32': 'sleep', '34': 'personcount', '37': 'other', '38': 'person', '98': 'face', '55': 'oil',
|
|
|
+ '52': 'person,hand,ball', '53': 'rope', '54': 'person', '39': 'person',
|
|
|
+ '11': 'blue,greent,whitet,bluecoat,whitebarcoat,graycoat,baoan,chenyi,other', '12': 'phone',
|
|
|
+ '66': 'extinguisher', '67': 'person,head,helmet,belt', '68': 'person', '35': 'barearm,arm',
|
|
|
+ '36': 'person,foot,cart,bag,box', '33': 'handbox,handbag','62':'hand'}
|
|
|
+modelalgdir = {}
|
|
|
+personcountdir = {}
|
|
|
+for key, value in modelnamedir.items():
|
|
|
+ modelalgdir[value] = key
|
|
|
+taskmap = {'helmet': newHelmet, 'uniform': newUniform, 'fall': newFall, 'personcount': Personcount, 'arm': Arm, 'bag': Bag,
|
|
|
+ 'cross': Cross, 'extinguisher': Extinguisher, 'persontre': newPersontre, 'bag': Bag, 'danager': Danager,'belt':CarHelmetBelt,'clear':Clear}
|
|
|
+mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
|
|
|
+test = transforms.Compose([transforms.Resize((224, 224)),
|
|
|
+ # transforms.CenterCrop(224),
|
|
|
+ transforms.ToTensor(),
|
|
|
+ transforms.Normalize(mean=mean, std=std)
|
|
|
+ ])
|
|
|
+def clapre(modelcla, claimg, clapoint):
|
|
|
+ imgten = torch.stack(claimg, dim=0)
|
|
|
+ clapoint = torch.stack(clapoint, dim=0)
|
|
|
+ imgten = imgten.to(0)
|
|
|
+ result = modelcla(imgten)
|
|
|
+ result = F.softmax(result)
|
|
|
+ print(result)
|
|
|
+ index = result.argmax(1)
|
|
|
+ index = index.cpu().numpy()
|
|
|
+ index = np.argwhere(index < 5)
|
|
|
+ index = index.reshape(-1)
|
|
|
+ print(index)
|
|
|
+ if len(index) > 0:
|
|
|
+ print(clapoint[index])
|
|
|
+ return clapoint[index]
|
|
|
+ else:
|
|
|
+ return None
|
|
|
+class YoloOpt:
|
|
|
+ def __init__(self, weights=ROOT / 'yolov5s.pt', source=ROOT / 'data/images', data=ROOT / 'data/coco128.yaml',
|
|
|
+ imgsz=(640, 640),
|
|
|
+ conf_thres=0.25,
|
|
|
+ iou_thres=0.45,
|
|
|
+ max_det=1000,
|
|
|
+ device='',
|
|
|
+ view_img=False,
|
|
|
+ save_txt=False,
|
|
|
+ save_conf=False,
|
|
|
+ save_crop=False,
|
|
|
+ nosave=True,
|
|
|
+ classes=None,
|
|
|
+ agnostic_nms=False,
|
|
|
+ augment=False,
|
|
|
+ visualize=False,
|
|
|
+ update=False,
|
|
|
+ project=ROOT / 'runs/detect',
|
|
|
+ name='exp',
|
|
|
+ exist_ok=False,
|
|
|
+ line_thickness=1,
|
|
|
+ hide_labels=False,
|
|
|
+ hide_conf=False,
|
|
|
+ half=False,
|
|
|
+ dnn=False,
|
|
|
+ vid_stride=10,
|
|
|
+ classify=False,
|
|
|
+ v8=False):
|
|
|
+ self.weights = weights # 权重文件地址
|
|
|
+ self.source = source # 待识别的图像
|
|
|
+ self.data = data
|
|
|
+ if imgsz is None:
|
|
|
+ self.imgsz = (640, 640)
|
|
|
+ self.imgsz = imgsz # 输入图片的大小，默认 (640,640)
|
|
|
+ self.conf_thres = conf_thres # object置信度阈值 默认0.25 用在nms中
|
|
|
+ self.iou_thres = iou_thres # 做nms的iou阈值 默认0.45 用在nms中
|
|
|
+ self.device = device # 执行代码的设备，由于项目只能用 CPU，这里只封装了 CPU 的方法
|
|
|
+ self.view_img = view_img # 是否展示预测之后的图片或视频 默认False
|
|
|
+ self.classes = classes # 只保留一部分的类别，默认是全部保留
|
|
|
+ self.agnostic_nms = agnostic_nms # 进行NMS去除不同类别之间的框, 默认False
|
|
|
+ self.augment = augment # augmented inference TTA测试时增强/多尺度预测，可以提分
|
|
|
+ self.update = update # 如果为True,则对所有模型进行strip_optimizer操作,去除pt文件中的优化器等信息,默认为False
|
|
|
+ self.exist_ok = exist_ok # 如果为True,则对所有模型进行strip_optimizer操作,去除pt文件中的优化器等信息,默认为False
|
|
|
+ self.project = project # 保存测试日志的参数，本程序没有用到
|
|
|
+ self.name = name # 每次实验的名称，本程序也没有用到
|
|
|
+ self.max_det = max_det
|
|
|
+ self.save_txt = save_txt
|
|
|
+ self.save_conf = save_conf
|
|
|
+ self.save_crop = save_crop
|
|
|
+ self.nosave = nosave
|
|
|
+ self.visualize = visualize
|
|
|
+ self.line_thickness = line_thickness
|
|
|
+ self.hide_labels = hide_labels
|
|
|
+ self.hide_conf = hide_conf
|
|
|
+ self.half = half
|
|
|
+ self.dnn = dnn
|
|
|
+ self.vid_stride = vid_stride
|
|
|
+ self.classify = classify
|
|
|
+ self.v8 = v8
|
|
|
+class Detect:
|
|
|
+ def __init__(self, weights=ROOT / 'yolov5s.pt', imgsz=(640, 640), source="changshusql1103.db", classes=None,
|
|
|
+ device=None, classify=False, conf_thres=0.25, v8=False):
|
|
|
+ print(f'detectweights = {weights}')
|
|
|
+ if v8:
|
|
|
+ from ultralytics.nn.autobackend import AutoBackend
|
|
|
+ from ultralytics.utils.ops import non_max_suppression
|
|
|
+ else:
|
|
|
+ from utils.general import non_max_suppression
|
|
|
+ self.opt = YoloOpt(weights=weights, imgsz=imgsz, source=source, classes=classes, device=device,
|
|
|
+ classify=classify, conf_thres=conf_thres, v8=v8)
|
|
|
+ self.source = str(self.opt.source)
|
|
|
+ self.save_img = not self.opt.nosave and not source.endswith('.txt') # save inference images
|
|
|
+ is_file = Path(self.source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
|
|
|
+ is_url = self.source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))
|
|
|
+ self.webcam = self.source.isnumeric() or source.endswith('.db') or (is_url and not is_file)
|
|
|
+ screenshot = self.source.lower().startswith('screen')
|
|
|
+ if is_url and is_file:
|
|
|
+ self.source = check_file(self.source) # download
|
|
|
+ self.save_dir = increment_path(Path(self.opt.project) / self.opt.name,
|
|
|
+ exist_ok=self.opt.exist_ok) # increment run
|
|
|
+ # self.save_dir = self.save_dir / Path(self.opt.weights).stem
|
|
|
+ # self.save_dir.mkdir(parents=True, exist_ok=True)
|
|
|
+ (self.save_dir / 'labels' if self.opt.save_txt else self.save_dir).mkdir(parents=True,
|
|
|
+ exist_ok=True) # make dir
|
|
|
+ print(f'device = {self.opt.device}')
|
|
|
+ device = select_device(self.opt.device)
|
|
|
+ if v8:
|
|
|
+ self.model = AutoBackend(self.opt.weights, device=device, dnn=self.opt.dnn, data=self.opt.data,
|
|
|
+ fp16=self.opt.half)
|
|
|
+ if Path(weights).stem in ['arm', 'uniform','fall','persontre','belt']:
|
|
|
+ if Path(weights).stem == 'arm':
|
|
|
+ self.personmodel = AutoBackend('yolov8m.pt', device=device, dnn=self.opt.dnn, data=self.opt.data,
|
|
|
+ fp16=self.opt.half)
|
|
|
+ elif Path(weights).stem in ['uniform','fall','persontre','belt']:
|
|
|
+ self.personmodel = AutoBackend('yolo11m.pt', device=device, dnn=self.opt.dnn, data=self.opt.data,
|
|
|
+ fp16=self.opt.half)
|
|
|
+ else:
|
|
|
+ self.model = DetectMultiBackend(self.opt.weights, device=device, dnn=self.opt.dnn, data=self.opt.data,
|
|
|
+ fp16=self.opt.half)
|
|
|
+ if Path(weights).stem in ['helmet', 'arm']:
|
|
|
+ self.personmodel = DetectMultiBackend('personcount.pt', device=device, dnn=self.opt.dnn,
|
|
|
+ data=self.opt.data, fp16=self.opt.half)
|
|
|
+ self.stride, self.names, self.pt = self.model.stride, self.model.names, self.model.pt
|
|
|
+ self.classify = classify
|
|
|
+ if self.classify:
|
|
|
+ if Path(weights).stem != "arm":
|
|
|
+ classifier_model = torch.load(f"{Path(weights).stem}cls.pt")
|
|
|
+ self.classifier_model = classifier_model.to(device)
|
|
|
+ self.classifier_model.eval()
|
|
|
+ else:
|
|
|
+ self.classifier_model = AutoBackend(f"{Path(weights).stem}cls.pt", device=device, dnn=self.opt.dnn,
|
|
|
+ data=self.opt.data, fp16=self.opt.half)
|
|
|
+ #self.imgsz = check_img_size(self.opt.imgsz, s=self.stride)
|
|
|
+ if Path(weights).stem in ['helmet','uniform'] :
|
|
|
+ self.imgsz = [960,960]
|
|
|
+ elif Path(weights).stem in ['persontre']:
|
|
|
+ self.imgsz = [1280,1280]
|
|
|
+ else:
|
|
|
+ self.imgsz = [640,640]
|
|
|
+ self.model.warmup(imgsz=(1, 3, *self.imgsz))
|
|
|
+ self.readpoint()
|
|
|
+ savefold = Path(f'/home/h3c/yolo/log/{Path(weights).stem}')
|
|
|
+ savefold.mkdir(parents=True, exist_ok=True)
|
|
|
+ logger.remove()
|
|
|
+ self.logger = logger.bind(process_log=f'/home/h3c/yolo/log/{Path(weights).stem}/file.log')
|
|
|
+ self.logger.add(f'./log/{Path(weights).stem}/file.log', rotation="1 GB",retention="3 days")
|
|
|
+ #self.logger.remove()
|
|
|
+ print(self.imgsz)
|
|
|
+ self.updatetime = time.time()
|
|
|
+ self.updatemtime = time.time()
|
|
|
+ self.filetime = os.path.getmtime(self.opt.weights)
|
|
|
+ self.taskname = taskmap[Path(self.opt.weights).stem]()
|
|
|
+ t1 = threading.Thread(target=self.load, daemon=True)
|
|
|
+ t1.start()
|
|
|
+
|
|
|
+ @smart_inference_mode()
|
|
|
+ def infer(self, queue, runmodel):
|
|
|
+ pretime = time.time()
|
|
|
+ seen, windows, self.dt = 0, [], (Profile(), Profile(), Profile())
|
|
|
+ #
|
|
|
+ # print ("数据库打开成功")
|
|
|
+ while True:
|
|
|
+ if time.localtime().tm_hour not in range(7, 20):
|
|
|
+ time.sleep(30)
|
|
|
+ continue
|
|
|
+ # print('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
|
|
|
+ if time.time() - pretime > 300:
|
|
|
+ ret = self.readpoint()
|
|
|
+ pretime = time.time()
|
|
|
+ if not ret:
|
|
|
+ print(f'{Path(self.opt.weights).stem} {runmodel}')
|
|
|
+ runmodel.pop(Path(self.opt.weights).stem)
|
|
|
+ print(f'{Path(self.opt.weights).stem} {runmodel}')
|
|
|
+ break
|
|
|
+ print(f'queuelen = {len(queue)}')
|
|
|
+ for que in queue:
|
|
|
+ if que.qsize() == 0:
|
|
|
+ print('queuezero')
|
|
|
+ time.sleep(0.01)
|
|
|
+ if que.qsize() > 0:
|
|
|
+ # if time.time()-pretime>300:
|
|
|
+ # ret = self.readpoint()
|
|
|
+ # pretime = time.time()
|
|
|
+ # if not ret:
|
|
|
+ # print(f'{Path(self.opt.weights).stem} {runmodel}')
|
|
|
+ # runmodel.pop(Path(self.opt.weights).stem)
|
|
|
+ # print(f'{Path(self.opt.weights).stem} {runmodel}')
|
|
|
+ # break
|
|
|
+ setframe = que.get()
|
|
|
+ # print('bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
|
|
|
+ # if setframe is not None
|
|
|
+ path, im0s, vid_cap, s, videotime, channels = setframe
|
|
|
+ algchannel = list(self.dirmodel.keys())
|
|
|
+ print(algchannel)
|
|
|
+ print(path)
|
|
|
+ algchannel = np.array(algchannel)
|
|
|
+ channelsnp = np.array(channels)
|
|
|
+ algindex = np.where(np.in1d(channelsnp, algchannel))[0]
|
|
|
+ algindex = list(algindex)
|
|
|
+ path = np.array(path)
|
|
|
+ path = path[algindex]
|
|
|
+ path = path.tolist()
|
|
|
+ channels = np.array(channels)
|
|
|
+ channels = channels[algindex]
|
|
|
+ channels = channels.tolist()
|
|
|
+ # print(algindex)
|
|
|
+ if len(algindex) == 0:
|
|
|
+ continue
|
|
|
+ # for ia in algindex:
|
|
|
+ # print(type(im0s[ia]))
|
|
|
+ # print(im0s[ia].shape)
|
|
|
+ #im = im[algindex]
|
|
|
+ # for ia in algindex:
|
|
|
+ # print(type(ia))
|
|
|
+ try:
|
|
|
+ im0s = np.asarray(im0s)
|
|
|
+ except Exception:
|
|
|
+ im0s = np.asarray(im0s, dtype=object)
|
|
|
+ print(im0s.shape)
|
|
|
+ im0s = im0s[algindex]
|
|
|
+ if '61' in channels:
|
|
|
+ self.pt = False
|
|
|
+ im = preprocess(im0s,self.pt,self.imgsz,self.stride)
|
|
|
+ # im0s = im0s.tolist()
|
|
|
+ print(f'algindex = {algindex}')
|
|
|
+ print(f'im0s ={im0s[0].shape}')
|
|
|
+ videotime = np.array(videotime)
|
|
|
+ videotime = videotime[algindex]
|
|
|
+ videotime = tuple(map(tuple, videotime))
|
|
|
+
|
|
|
+ with self.dt[0]:
|
|
|
+ im = torch.from_numpy(im).to(self.model.device)
|
|
|
+ im = im.half() if self.model.fp16 else im.float() # uint8 to fp16/32
|
|
|
+ im /= 255 # 0 - 255 to 0.0 - 1.0
|
|
|
+ if len(im.shape) == 3:
|
|
|
+ im = im[None] # expand for batch dim
|
|
|
+ # Inference
|
|
|
+ with self.dt[1]:
|
|
|
+ visualize = increment_path(self.save_dir / Path(path).stem,
|
|
|
+ mkdir=True) if self.opt.visualize else False
|
|
|
+ # print('error')
|
|
|
+ # print(self.model)
|
|
|
+ pred = self.model(im, augment=self.opt.augment, visualize=visualize)
|
|
|
+ self.postprocess(pred, path, im0s, im, s, videotime, channels)
|
|
|
+
|
|
|
+ def postprocess(self, pred, path, im0s, im, s, videotime, channels):
|
|
|
+ if time.time() - self.updatemtime > 300:
|
|
|
+ if self.filetime != os.path.getmtime(self.opt.weights):
|
|
|
+ try:
|
|
|
+ device = select_device(self.opt.device)
|
|
|
+ print("load new load")
|
|
|
+ self.model = DetectMultiBackend(self.opt.weights, device=device, dnn=self.opt.dnn, data=self.opt.data,
|
|
|
+ fp16=self.opt.half)
|
|
|
+ self.stride, self.names, self.pt = self.model.stride, self.model.names, self.model.pt
|
|
|
+ self.filetime = os.path.getmtime(self.opt.weights)
|
|
|
+ except Exception:
|
|
|
+ print("load error")
|
|
|
+ # try:
|
|
|
+ # if modelalgdir[Path(self.opt.weights).stem]!='0':
|
|
|
+ print(modelalgdir[Path(self.opt.weights).stem])
|
|
|
+ try:
|
|
|
+ rea = requests.post(url=urla, data={'algorithmCode': modelalgdir[Path(self.opt.weights).stem]}).json()[
|
|
|
+ 'data']
|
|
|
+ con = rea[0]['confidence']
|
|
|
+ self.opt.conf_thres = con
|
|
|
+ except Exception:
|
|
|
+ print('error')
|
|
|
+
|
|
|
+ self.updatemtime = time.time()
|
|
|
+ seen = 0
|
|
|
+ # dt = (Profile(), Profile(), Profile())
|
|
|
+ print(f'senn = {seen}')
|
|
|
+ windows = []
|
|
|
+ if Path(self.opt.weights).stem:
|
|
|
+ labelnamelist = []
|
|
|
+ with self.dt[2]:
|
|
|
+ # print(f'cropshape={pred.shape}')
|
|
|
+ if self.opt.v8:
|
|
|
+ from ultralytics.utils.ops import non_max_suppression
|
|
|
+ else:
|
|
|
+ from utils.general import non_max_suppression
|
|
|
+ if Path(self.opt.weights).stem == "fall":
|
|
|
+ pred = non_max_suppression(pred, self.opt.conf_thres, self.opt.iou_thres, self.opt.classes,
|
|
|
+ self.opt.agnostic_nms, max_det=self.opt.max_det,nc=1)
|
|
|
+ else:
|
|
|
+ pred = non_max_suppression(pred, self.opt.conf_thres, self.opt.iou_thres, self.opt.classes,
|
|
|
+ self.opt.agnostic_nms, max_det=self.opt.max_det)
|
|
|
+ # Second-stage classifier (optional)
|
|
|
+ # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
|
|
|
+ if self.classify and Path(self.opt.weights).stem != 'persontre':
|
|
|
+ if Path(self.opt.weights).stem == 'arm':
|
|
|
+ pred = apply_classifierarm(pred, self.classifier_model, im, im0s, Path(self.opt.weights).stem)
|
|
|
+ else:
|
|
|
+ pred = apply_classifier1(pred, self.classifier_model, im, im0s, Path(self.opt.weights).stem)
|
|
|
+ # Process predictions
|
|
|
+ # print(f'predshape={pred.shape}')
|
|
|
+ for i, det in enumerate(pred): # per image
|
|
|
+ if time.time() - self.updatetime > 300:
|
|
|
+ dataele = {
|
|
|
+ "algorithmCode": self.dirmodel[channels[i]]['classindex'],
|
|
|
+ "algorithmIp": self.dirmodel[channels[i]]['algip'],
|
|
|
+ "channel": self.dirmodel[channels[i]]['channel']
|
|
|
+ }
|
|
|
+ try:
|
|
|
+ resultele = requests.post(url=urlele, data=dataele).json()['data']['pointCollections']
|
|
|
+ resultele = resultele.split(',||')
|
|
|
+ resultele = tuple(resultele)
|
|
|
+ point = '%s:' * len(resultele) % resultele
|
|
|
+ if len(point[:-2]) > 1:
|
|
|
+ self.dirmodel[channels[i]]['point'] = point[:-2]
|
|
|
+ except Exception:
|
|
|
+ print('post error')
|
|
|
+ if Path(self.opt.weights).stem == 'personcount':
|
|
|
+ try:
|
|
|
+ resultper = requests.post(url=urlperson, data=dataele).json()['data']
|
|
|
+ personcountdir[channels[i]] = int(resultper)
|
|
|
+ except Exception:
|
|
|
+ print('urlpersonerror')
|
|
|
+ if Path(self.opt.weights).stem == 'sleep' or Path(self.opt.weights).stem == 'duty':
|
|
|
+ datatime = {
|
|
|
+ "algorithmCode": self.dirmodel[channels[i]]['classindex'],
|
|
|
+ "algorithmIp": self.dirmodel[channels[i]]['algip'],
|
|
|
+ "channel": self.dirmodel[channels[i]]['channel']
|
|
|
+ }
|
|
|
+ try:
|
|
|
+ resulttime = requests.post(url=urltime, data=dataele).json()['data']
|
|
|
+ self.dirmodel[channel]['durtime'] = int(resulttime)
|
|
|
+ except Exception:
|
|
|
+ print('posttime error')
|
|
|
+ self.updatetime = time.time()
|
|
|
+ seen += 1
|
|
|
+ if self.webcam: # batch_size >= 1
|
|
|
+ p, im0 = path[i], im0s[i].copy()
|
|
|
+ s += f'{i}: '
|
|
|
+ else:
|
|
|
+ p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)
|
|
|
+ p = Path(p) # to Path
|
|
|
+ save_path = str(self.save_dir / p.name) # im.jpg
|
|
|
+ # txt_path = str(self.save_dir / 'labels' / p.stem) + (
|
|
|
+ # '' #if dataset.mode == 'image' else f'_{frame}') # im.txt
|
|
|
+ s += '%gx%g ' % im.shape[2:] # print string
|
|
|
+ gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
|
|
|
+ imc = im0.copy() # for save_crop
|
|
|
+ annotator = Annotator(im0, line_width=self.opt.line_thickness, example=str(self.names))
|
|
|
+ flag = False
|
|
|
+ if len(det) and Path(self.opt.weights).stem != 'duty':
|
|
|
+ # flag = True
|
|
|
+ # Rescale boxes from img_size to im0 size
|
|
|
+ det[:, :4] = scale_boxes(im.shape[2:], det[:, :4], im0.shape).round()
|
|
|
+ # Print results
|
|
|
+ for c in det[:, 5].unique():
|
|
|
+ n = (det[:, 5] == c).sum() # detections per class
|
|
|
+ s += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " # add to string
|
|
|
+ # Write results
|
|
|
+ if Path(self.opt.weights).stem in ['arm', 'uniform','fall','persontre','belt']:
|
|
|
+ personpred = self.personmodel(im[i][None], None, None)
|
|
|
+ personpred = non_max_suppression(personpred, 0.7, self.opt.iou_thres, 0,
|
|
|
+ self.opt.agnostic_nms, max_det=self.opt.max_det)
|
|
|
+ if len(personpred[0]) == 0:
|
|
|
+ flag = False
|
|
|
+ elif Path(self.opt.weights).stem == 'other':
|
|
|
+ persondet = []
|
|
|
+ personpred = personpred[0]
|
|
|
+ personpred[:, :4] = scale_boxes(im.shape[2:], personpred[:, :4], im0.shape).round()
|
|
|
+ for *perxyxy, conf, cls in reversed(personpred):
|
|
|
+ print(perxyxy)
|
|
|
+ x1, y1, x3, y3 = perxyxy
|
|
|
+ x1, y1, x3, y3 = int(x1), int(y1), int(x3), int(y3)
|
|
|
+ x2, y2 = x3, y1
|
|
|
+ x4, y4 = x1, y3
|
|
|
+ flag = self.taskname.getflag(det, persondet, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'],channel=channls[i])
|
|
|
+ else:
|
|
|
+ persondet = []
|
|
|
+ personpred = personpred[0]
|
|
|
+ personpred[:, :4] = scale_boxes(im.shape[2:], personpred[:, :4], im0.shape).round()
|
|
|
+ for *perxyxy, conf, cls in reversed(personpred):
|
|
|
+ print(perxyxy)
|
|
|
+ if conf < 0.8:
|
|
|
+ continue
|
|
|
+ x1, y1, x3, y3 = perxyxy
|
|
|
+ x1, y1, x3, y3 = int(x1), int(y1), int(x3), int(y3)
|
|
|
+ x2, y2 = x3, y1
|
|
|
+ x4, y4 = x1, y3
|
|
|
+ persondet.append([x1, y1, x2, y2, x3, y3, x4, y4])
|
|
|
+ if Path(self.opt.weights).stem == "fall":
|
|
|
+ flag = self.taskname.getflag(det, persondet, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'],imshape=im.shape[2:],channel=channels[i])
|
|
|
+ else:
|
|
|
+ flag = self.taskname.getflag(det, persondet, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'],channel=channels[i])
|
|
|
+ else:
|
|
|
+ if Path(self.opt.weights).stem in ['personcount']:
|
|
|
+ flag = self.taskname.getflag(det, None, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'], personcountdir[channels[i]],channel=channels[i])
|
|
|
+ elif Path(self.opt.weights).stem in ['persontre']:
|
|
|
+ flag = self.taskname.getflag(det, None, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'], 1, imc,channel=channels[i])
|
|
|
+ else:
|
|
|
+ flag = self.taskname.getflag(det, None, annotator, self.dirmodel[channels[i]]['fence'],
|
|
|
+ self.dirmodel[channels[i]]['point'], self.names,
|
|
|
+ self.dirmodel[channels[i]]['label'],channel=channels[i])
|
|
|
+ if flag:
|
|
|
+ # if self.dirmodel[channels[i]]['imgtime'] != videotime[i]:
|
|
|
+ self.dirmodel[channels[i]]['detframe'].pop(0)
|
|
|
+ self.dirmodel[channels[i]]['detframe'].append(1)
|
|
|
+ self.dirmodel[channels[i]]['preim'] = annotator.result()
|
|
|
+ self.dirmodel[channels[i]]['oripreim'] = imc
|
|
|
+ self.dirmodel[channels[i]]['posttime'] = videotime[i]
|
|
|
+ print(self.dirmodel[channels[i]]['detframe'])
|
|
|
+ # self.dirmodel[channels[i]]['imgtime'] = videotime[i]
|
|
|
+ else:
|
|
|
+ # print(f'deti= {i}')
|
|
|
+ # print(detframe[i])
|
|
|
+ # if self.dirmodel[channels[i]]['imgtime'] != videotime[i]:
|
|
|
+ self.dirmodel[channels[i]]['detframe'].pop(0)
|
|
|
+ self.dirmodel[channels[i]]['detframe'].append(0)
|
|
|
+ print(self.dirmodel[channels[i]]['detframe'])
|
|
|
+
|
|
|
+ if not self.dirmodel[channels[i]]['detflag'] and self.dirmodel[channels[i]]['detframe'].count(1) >= 1:
|
|
|
+ self.dirmodel[channels[i]]['detflag'] = True
|
|
|
+ self.dirmodel[channels[i]]['detpretime'] = time.time()
|
|
|
+ elif self.dirmodel[channels[i]]['detframe'].count(1) == 0:
|
|
|
+ self.dirmodel[channels[i]]['detflag'] = False
|
|
|
+ self.dirmodel[channels[i]]['detpretime'] = float('inf')
|
|
|
+ # Stream results
|
|
|
+ # im0 = annotator.result()
|
|
|
+ if time.time() - self.dirmodel[channels[i]]['postpretime'] > 30 and time.time() - \
|
|
|
+ self.dirmodel[channels[i]]['detpretime'] > self.dirmodel[channels[i]]['durtime'] and \
|
|
|
+ self.dirmodel[channels[i]]['detflag']:
|
|
|
+
|
|
|
+ print('post-------------------------------------------------------------------------')
|
|
|
+ # time.sleep(30)
|
|
|
+ # print(time.time() - postpretime[i])
|
|
|
+ # print('111111111111111111111111111111111111111111111111')
|
|
|
+ # print(dirmodel[channels[i]]['preim'].shape)
|
|
|
+ success, encoded_image = cv2.imencode('.jpg', self.dirmodel[channels[i]]['preim'])
|
|
|
+ content = encoded_image.tobytes()
|
|
|
+ successori, encoded_imageori = cv2.imencode('.jpg', self.dirmodel[channels[i]]['oripreim'])
|
|
|
+ contentori = encoded_imageori.tobytes()
|
|
|
+ filename = f'{p.stem}_{int(time.time())}.jpg'
|
|
|
+ filenameori = f'ori{p.stem}_{int(time.time())}.jpg'
|
|
|
+ print(f'str(p) {p.name}')
|
|
|
+ print(channels[i])
|
|
|
+
|
|
|
+ #交互大模型
|
|
|
+ if Path(self.opt.weights).stem in ['uniform','fall','persontre', 'helmet']:
|
|
|
+ postdir = {'image_base64':numpy_image_to_base64(self.dirmodel[channels[i]]['oripreim']),'question':questiondir[Path(self.opt.weights).stem]}
|
|
|
+
|
|
|
+ response = requests.post(urlque,json=postdir).json()['data']['answer']
|
|
|
+ #print(f'response = {response}')
|
|
|
+
|
|
|
+ #if random.choice([True, False]):
|
|
|
+ if "是" in response and (Path(self.opt.weights).stem == "uniform" or Path(self.opt.weights).stem == "helmet"):
|
|
|
+ continue
|
|
|
+ if "否" in response and (Path(self.opt.weights).stem == "fall" or Path(self.opt.weights).stem == "persontre"):
|
|
|
+ continue
|
|
|
+ payload = {'channel': self.dirmodel[channels[i]]['channel'],
|
|
|
+ 'classIndex': self.dirmodel[channels[i]]['classindex'],
|
|
|
+ 'ip': self.dirmodel[channels[i]]['algip'],
|
|
|
+ 'videoTime': time.strftime('%Y-%m-%d %H:%M:%S', self.dirmodel[channels[i]]['posttime']),
|
|
|
+ 'videoUrl': channels[i]}
|
|
|
+ files = [
|
|
|
+ ('file', (filename, content, 'image/jpeg')),
|
|
|
+ ('oldFile', (filenameori, contentori, 'image/jpeg')),
|
|
|
+ ]
|
|
|
+ try:
|
|
|
+ result = requests.post(url, data=payload, files=files)
|
|
|
+ print(result)
|
|
|
+ except Exception:
|
|
|
+ print('posterror')
|
|
|
+ # time.sleep(3000)
|
|
|
+ self.dirmodel[channels[i]]['postpretime'] = time.time()
|
|
|
+ self.dirmodel[channels[i]]['detflag'] = False
|
|
|
+ timesave = time.strftime('%Y-%m-%d-%H:%M:%S', self.dirmodel[channels[i]]['posttime'])
|
|
|
+ year = time.strftime('%Y', time.localtime(time.time()))
|
|
|
+ month = time.strftime('%m', time.localtime(time.time()))
|
|
|
+ day = time.strftime('%d', time.localtime(time.time()))
|
|
|
+ savefold = f'/mnt/project/images/{Path(self.opt.weights).stem}/{year}/{month}/{day}'
|
|
|
+ savefold = Path(savefold)
|
|
|
+ savefold.mkdir(parents=True, exist_ok=True)
|
|
|
+ detsavefold = f'/mnt/project/detimages/{Path(self.opt.weights).stem}/{year}/{month}/{day}'
|
|
|
+ detsavefold = Path(detsavefold)
|
|
|
+ detsavefold.mkdir(parents=True, exist_ok=True)
|
|
|
+ cv2.imwrite(f'{savefold}/{timesave}.jpg', self.dirmodel[channels[i]]['oripreim'])
|
|
|
+ cv2.imwrite(f'{detsavefold}/{timesave}det.jpg', self.dirmodel[channels[i]]['preim'])
|
|
|
+ # if self.dirmodel[channels[i]]['detframe'].count(1)==0:
|
|
|
+ # self.dirmodel[channels[i]]['detflag'] = False
|
|
|
+ # time.sleep(1)
|
|
|
+ self.view_img = False
|
|
|
+ if self.view_img:
|
|
|
+ if platform.system() == 'Linux' and p not in windows:
|
|
|
+ windows.append(p)
|
|
|
+ cv2.namedWindow(f'{str(p)}-{Path(self.opt.weights).stem}',
|
|
|
+ cv2.WINDOW_NORMAL | cv2.WINDOW_KEEPRATIO) # allow window resize (Linux)
|
|
|
+ cv2.resizeWindow(f'{str(p)}-{Path(self.opt.weights).stem}', im0.shape[1], im0.shape[0])
|
|
|
+ im1 = cv2.resize(im0, (1280, 720))
|
|
|
+ cv2.imshow(f'{str(p)}-{Path(self.opt.weights).stem}', im1)
|
|
|
+ cv2.waitKey(1) # 1 millisecond
|
|
|
+ # Save results (image with detections)
|
|
|
+ # Print time (inference-only)
|
|
|
+ print(f'channels[i]={channels[i]}')
|
|
|
+ #LOGGER.info(
|
|
|
+ # f"{s}{'' if len(det) else '(no detections), '}{self.dt[1].dt * 1E3:.1f}ms {str(p)}-{Path(self.opt.weights).stem}")
|
|
|
+ self.logger.info(f"{s}{'' if len(det) else '(no detections), '}{self.dt[1].dt * 1E3:.1f}ms {str(p)}-{Path(self.opt.weights).stem}")
|
|
|
+ def load(self):
|
|
|
+ conn = sqlite3.connect(self.source)
|
|
|
+ c = conn.cursor()
|
|
|
+ while True:
|
|
|
+ #
|
|
|
+ # print ("数据库打开成功")
|
|
|
+ cursor = c.execute(
|
|
|
+ "SELECT modelname, addstream,delstream,streaming from CHANGESTREAM WHERE modelname= (?)",
|
|
|
+ (Path(self.opt.weights).stem,))
|
|
|
+
|
|
|
+ self.contentid = cursor.fetchall()
|
|
|
+ # global tag
|
|
|
+ # tag = Value('i', self.contentid[0][3])
|
|
|
+ # print(tag.value==1)
|
|
|
+ print(f'loadcontent={self.contentid[0][3]}')
|
|
|
+ time.sleep(3)
|
|
|
+ c.close()
|
|
|
+ conn.close()
|
|
|
+
|
|
|
+ def readpoint(self):
|
|
|
+ data = {
|
|
|
+ "algorithmCode": modelalgdir[Path(self.opt.weights).stem],
|
|
|
+ "deviceIp": None,
|
|
|
+ 'fwqCode': None
|
|
|
+ }
|
|
|
+ self.dirmodel = {}
|
|
|
+ result = requests.post(url=urlt, data=data).json()['data']
|
|
|
+ channell = []
|
|
|
+ for info in result:
|
|
|
+ # content = cursor.fetchall()
|
|
|
+ # self.dirmodel = {}
|
|
|
+ # for address,fence,point,channel,classindex,ip ,algip,label,durtime in content:
|
|
|
+ # address = f'{address[:-1]}0'
|
|
|
+ channel = info["deviceChannel"]
|
|
|
+ if Path(self.opt.weights).stem == "danager" and channel == '45':
|
|
|
+ continue
|
|
|
+ channell.append(channel)
|
|
|
+ self.dirmodel[channel] = {}
|
|
|
+ self.dirmodel[channel]['fence'] = 1 if len(info["electricFence"]) > 0 else 0
|
|
|
+ if Path(self.opt.weights).stem == "uniform":
|
|
|
+ self.dirmodel[channel]['fence'] = 1
|
|
|
+ # self.dirmodel[channel]['point'] = point
|
|
|
+ self.dirmodel[channel]['channel'] = info['deviceChannel']
|
|
|
+ self.dirmodel[channel]['classindex'] = info['algorithmCode']
|
|
|
+ self.dirmodel[channel]['ip'] = info['deviceIp']
|
|
|
+ self.dirmodel[channel]['algip'] = info['deviceAlgorithmIp']
|
|
|
+ dataele = {
|
|
|
+ "algorithmCode": self.dirmodel[channel]['classindex'],
|
|
|
+ "algorithmIp": self.dirmodel[channel]['algip'],
|
|
|
+ "channel": self.dirmodel[channel]['channel']
|
|
|
+ }
|
|
|
+ resultele = requests.post(url=urlele, data=dataele).json()['data']['pointCollections']
|
|
|
+ resultele = resultele.split(',||')
|
|
|
+ resultele = tuple(resultele)
|
|
|
+ point = '%s:' * len(resultele) % resultele
|
|
|
+ if Path(self.opt.weights).stem == 'personcount':
|
|
|
+ resultper = requests.post(url=urlperson, data=dataele).json()['data']
|
|
|
+ personcountdir[channel] = int(resultper)
|
|
|
+ if (Path(self.opt.weights).stem == "uniform") and len(
|
|
|
+ point[:-2]) <= 1:
|
|
|
+ self.dirmodel[channel]['point'] = "150#144,1100#144,1100#550,150#550"
|
|
|
+ else:
|
|
|
+ self.dirmodel[channel]['point'] = point[:-2]
|
|
|
+ self.dirmodel[channel]['preim'] = None
|
|
|
+ self.dirmodel[channel]['oripreim'] = None
|
|
|
+ self.dirmodel[channel]['detframe'] = [0 for _ in range(2)]
|
|
|
+ self.dirmodel[channel]['postpretime'] = 0
|
|
|
+ self.dirmodel[channel]['detflag'] = False
|
|
|
+ self.dirmodel[channel]['detpretime'] = float('inf')
|
|
|
+ self.dirmodel[channel]['label'] = modellabeldir[data['algorithmCode']]
|
|
|
+ if Path(self.opt.weights).stem == 'sleep' or Path(self.opt.weights).stem == 'duty':
|
|
|
+ datatime = {
|
|
|
+ "algorithmCode": self.dirmodel[channel]['classindex'],
|
|
|
+ "algorithmIp": self.dirmodel[channel]['algip'],
|
|
|
+ "channel": self.dirmodel[channel]['channel']
|
|
|
+ }
|
|
|
+ resulttime = requests.post(url=urltime, data=dataele).json()['data']
|
|
|
+ self.dirmodel[channel]['durtime'] = int(resulttime)
|
|
|
+ else:
|
|
|
+ self.dirmodel[channel]['durtime'] = 0
|
|
|
+ self.dirmodel[channel]['posttime'] = 0
|
|
|
+ return sorted(channell)
|
|
|
+
|
|
|
+def getframe(queuelist, channelsl, source, tt, numworks, lock, numworkv):
|
|
|
+ while True:
|
|
|
+ print("dataloader")
|
|
|
+ imgsz = [768, 768]
|
|
|
+ print(f'source = {source}')
|
|
|
+ dataset = LoadStreamsSQLTNP(channelsl, source, img_size=896,
|
|
|
+ auto=True, vid_stride=20, tt=tt, numworks=numworks)
|
|
|
+ bs = len(dataset)
|
|
|
+ vid_path, vid_writer = [None] * bs, [None] * bs
|
|
|
+ # self.detframe = [[0 for _ in range(8)] for i in range(bs)]
|
|
|
+ # self.postpretime = [0]*bs
|
|
|
+ # Run inference
|
|
|
+ # imgsz = (1 , 3, *self.imgsz)
|
|
|
+ print(imgsz)
|
|
|
+ # self.model.warmup(imgsz=(1 , 3, *imgsz)) # warmup
|
|
|
+ seen, windows, dt = 0, [], (Profile(), Profile(), Profile())
|
|
|
+ #
|
|
|
+ # print ("数据库打开成功")
|
|
|
+ pretime = time.time()
|
|
|
+ tag = 0
|
|
|
+ sourcebase = 'project0117.db'
|
|
|
+ for path, im0s, vid_cap, s, videotime, channels in dataset:
|
|
|
+ if time.time() - pretime > 300:
|
|
|
+ channellist = []
|
|
|
+ pretime = time.time()
|
|
|
+ data = {
|
|
|
+ "algorithmCode": None,
|
|
|
+ "deviceIp": None,
|
|
|
+ "fwqCode": None
|
|
|
+ }
|
|
|
+ try:
|
|
|
+ result = requests.post(url=urlt, data=data).json()['data']
|
|
|
+ except Exception:
|
|
|
+ result = []
|
|
|
+ for info in result:
|
|
|
+ data = {
|
|
|
+ "channel": info["deviceChannel"],
|
|
|
+ "ip": info["deviceAlgorithmIp"]
|
|
|
+ }
|
|
|
+ chaflag = any(info["deviceChannel"] in t for t in channellist)
|
|
|
+ # personcountdir[channel] = num
|
|
|
+ if not chaflag:
|
|
|
+ address = requests.post(url=urlrtsp, data=data).json()['msg']
|
|
|
+ channellist.append((info['deviceChannel'], address))
|
|
|
+ channelsa = []
|
|
|
+ sourcea = []
|
|
|
+ channellist = set(channellist)
|
|
|
+ channellist = sorted(channellist, key=lambda x: x[0])
|
|
|
+ # channellist = set(channellist)
|
|
|
+ for cha, add in channellist:
|
|
|
+ channelsa.append(cha)
|
|
|
+ sourcea.append(add)
|
|
|
+ channelsl = sorted(channelsl)
|
|
|
+ # channelsa = sorted(channelsa)
|
|
|
+ if channelsa != channelsl and len(channelsa) > 0:
|
|
|
+ print(f'channelsa = {channelsa}')
|
|
|
+ print(f'channelsl = {channelsl}')
|
|
|
+ dataset.close()
|
|
|
+ channelsl = channelsa
|
|
|
+ source = sourcea
|
|
|
+ break;
|
|
|
+ for key, value in queuelist.items():
|
|
|
+ hour = time.localtime(time.time()).tm_hour
|
|
|
+ if hour in range(7, 19):
|
|
|
+ value[-1].put((path, im0s, vid_cap, s, videotime, channels))
|
|
|
+ value[-1].get() if value[-1].qsize() == 10 else time.sleep(0.001)
|
|
|
+
|
|
|
+def getmutpro(channels, source, streamlist, numworkv, lock, numworks=1, modellen=None):
|
|
|
+ processlist = []
|
|
|
+ queuelist = {}
|
|
|
+ for i in range(numworks):
|
|
|
+ for model in modellen:
|
|
|
+ queue = Queue(maxsize=10)
|
|
|
+ queuelist.setdefault(model, [])
|
|
|
+ queuelist[model].append(queue)
|
|
|
+ process = Process(target=getframe,
|
|
|
+ args=(queuelist, channels, source, i, numworks, lock, numworkv))
|
|
|
+ processlist.append(process)
|
|
|
+ process.start()
|
|
|
+ # queuelist.append(queue)
|
|
|
+ return queuelist
|
|
|
+
|
|
|
+def modelfun(queue, weights, sourcedb, classes, device, classify, conf_thres, runmodel, v8=False):
|
|
|
+ print(weights)
|
|
|
+ detectdemo = Detect(weights=weights, source=sourcedb, classes=classes, device=device, classify=classify,
|
|
|
+ conf_thres=conf_thres, v8=v8)
|
|
|
+ detectdemo.infer(queue, runmodel)
|
|
|
+
|
|
|
+def parse_opt():
|
|
|
+ parser = argparse.ArgumentParser()
|
|
|
+ parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s.pt', help='model path or triton URL')
|
|
|
+ opt = parser.parse_args()
|
|
|
+ return opt
|
|
|
+
|
|
|
+def main(opt):
|
|
|
+ check_requirements(ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))
|
|
|
+ run(**vars(opt))
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ # torch.multiprocessing.set_start_method('spawn')
|
|
|
+ # set_start_method('spawn')
|
|
|
+ opt = parse_opt()
|
|
|
+ dbpath = 'projectnew.db'
|
|
|
+ conn = sqlite3.connect(dbpath)
|
|
|
+ #
|
|
|
+ # print ("数据库打开成功")
|
|
|
+ c = conn.cursor()
|
|
|
+ task(c, conn, urlt, urla)
|
|
|
+ cursor = c.execute('select channel,algip from stream ')
|
|
|
+ result = cursor.fetchall()
|
|
|
+ for channel, algip in result:
|
|
|
+ data = {
|
|
|
+ "channel": channel,
|
|
|
+ "ip": algip
|
|
|
+ }
|
|
|
+ # personcountdir[channel] = num
|
|
|
+ address = requests.post(url=urlrtsp, data=data).json()['msg']
|
|
|
+ c.execute('UPDATE STREAM set address= (?) where channel =(?)', (address, channel))
|
|
|
+ conn.commit()
|
|
|
+ cursor = c.execute(
|
|
|
+ "SELECT modelname from CHANGESTREAM where modelname = 'helmet' or modelname = 'smoke' or modelname = 'uniform' or modelname = 'fire' or modelname ='duty' or modelname = 'sleep' or modelname='occupancy' or modelname = 'personcar' or modelname = 'phone' or modelname = 'reflective' or modelname = 'extinguisher' or modelname = 'danager' or modelname = 'inspection' or modelname = 'cross' or modelname = 'personcount' or modelname= 'arm' or modelname = 'persontre' or modelname = 'bag' or modelname = 'fall' or modelname = 'belt' or modelname = 'clear'")
|
|
|
+ # cursor = c.execute("SELECT modelname from CHANGESTREAM where modelname = 'helmet'")
|
|
|
+ content = cursor.fetchall()
|
|
|
+ cursor = c.execute("SELECT address,channel from STREAM ")
|
|
|
+ # cursor = c.execute("SELECT address from STREAM where modelname = 'helmet'")
|
|
|
+ contenta = cursor.fetchall()
|
|
|
+ source = []
|
|
|
+ modellist = []
|
|
|
+ addcha = []
|
|
|
+ channellist = []
|
|
|
+ for i in contenta:
|
|
|
+ addcha.append((i[0], i[1]))
|
|
|
+ # modellist.append(i[1])
|
|
|
+ addcha = set(addcha)
|
|
|
+ addcha = sorted(addcha, key=lambda x: x[1])
|
|
|
+ for add, cha in addcha:
|
|
|
+ source.append(add)
|
|
|
+ channellist.append(cha)
|
|
|
+ # source = set(source)
|
|
|
+ print(addcha)
|
|
|
+ source = list(source)
|
|
|
+ cursor = c.execute(
|
|
|
+ "SELECT modelname from STREAM where (modelname ='helmet' or modelname = 'smoke' or modelname = 'uniform' or modelname = 'fire' or modelname = 'duty' or modelname = 'sleep' or modelname='occupancy' or modelname = 'personcar' or modelname = 'phone' or modelname = 'reflective' or modelname = 'extinguisher' or modelname = 'danager' or modelname = 'inspection' or modelname = 'cross' or modelname = 'personcount' or modelname = 'arm' or modelname = 'persontre' or modelname = 'bag' or modelname = 'fall' or modelname = 'belt' or modelname = 'clear')")
|
|
|
+ contentm = cursor.fetchall()
|
|
|
+ for m in contentm:
|
|
|
+ modellist.append(m[0])
|
|
|
+ modellist = set(modellist)
|
|
|
+ modellist = list(modellist)
|
|
|
+ contentlist = []
|
|
|
+ for i in content:
|
|
|
+ contentlist.append(i[0])
|
|
|
+ # source.sort()
|
|
|
+ n = len(content)
|
|
|
+ print(f'modelname={n}')
|
|
|
+ print(content)
|
|
|
+ # content.reverse()
|
|
|
+ print(content)
|
|
|
+ print(source)
|
|
|
+ # main(opt)
|
|
|
+ # processes = []
|
|
|
+ streamqueue = Queue(maxsize=4)
|
|
|
+ numworkv = Value('i', 0)
|
|
|
+ manager = Manager()
|
|
|
+ lock = multiprocessing.Lock()
|
|
|
+ streamlist = manager.list()
|
|
|
+ numworks = 7
|
|
|
+ modellen = []
|
|
|
+ for i in modellist:
|
|
|
+ if i in contentlist:
|
|
|
+ modellen.append(i)
|
|
|
+ queuelist = getmutpro(channellist, source, streamlist, numworkv, lock, numworks, modellen)
|
|
|
+ deid = 0
|
|
|
+ # pool = ThreadPoolExecutor(max_workers=n)
|
|
|
+ runmodel = manager.dict()
|
|
|
+ while True:
|
|
|
+ for i in modellist:
|
|
|
+ if i in contentlist:
|
|
|
+ if i not in runmodel:
|
|
|
+ # print(i)
|
|
|
+ # detectdemo=Detect(weights=f'/mnt/project/yolodemo/yolov5-master/{i[0]}.pt')
|
|
|
+ c.execute('select conf,cla from changestream where modelname = (?)', (i,))
|
|
|
+ rea = c.fetchall()
|
|
|
+ print(f'weights ={i[0]}.pt')
|
|
|
+ if i in ['duty', 'danager', 'inspection', 'cross', 'personcount']:
|
|
|
+ process = Process(target=modelfun, args=(
|
|
|
+ queuelist[i], f'{i}.pt', dbpath, [0], 0, rea[0][1], rea[0][0], runmodel, True))
|
|
|
+ else:
|
|
|
+ if i in ['fall', 'extinguisher']:
|
|
|
+ process = Process(target=modelfun, args=(
|
|
|
+ queuelist[i], f'{i}.pt', dbpath, None, 0, rea[0][1], rea[0][0], runmodel,True))
|
|
|
+ else:
|
|
|
+ process = Process(target=modelfun, args=(
|
|
|
+ queuelist[i], f'{i}.pt', dbpath, None, 0, rea[0][1], rea[0][0], runmodel, True))
|
|
|
+ time.sleep(3)
|
|
|
+ process.start()
|
|
|
+ deid = deid + 1
|
|
|
+ runmodel[i] = 1
|
|
|
+ time.sleep(600)
|
|
|
+ task(c, conn, urlt, urla)
|
|
|
+ cursor = c.execute(
|
|
|
+ "SELECT modelname from CHANGESTREAM where modelname = 'helmet' or modelname = 'smoke' or modelname = 'uniform' or modelname = 'fire' or modelname ='duty' or modelname = 'sleep' or modelname='occupancy' or modelname = 'personcar' or modelname = 'phone' or modelname = 'reflective' or modelname = 'extinguisher' or modelname = 'danager' or modelname = 'inspection' or modelname = 'cross' or modelname = 'personcount' or modelname = 'arm' or modelname = 'persontre' or modelname = 'bag' or modelname = 'fall' or modelname = 'belt' or modelname = 'clear'")
|
|
|
+ content = cursor.fetchall()
|
|
|
+ contentlist = []
|
|
|
+ for con in content:
|
|
|
+ contentlist.append(con[0])
|
|
|
+ cursor = c.execute("SELECT address,channel from STREAM ")
|
|
|
+ contenta = cursor.fetchall()
|
|
|
+ source = []
|
|
|
+ modellist = []
|
|
|
+ addcha = []
|
|
|
+ channellist = []
|
|
|
+ for i in contenta:
|
|
|
+ addcha.append((i[0], i[1]))
|
|
|
+ # modellist.append(i[1])
|
|
|
+ addcha = set(addcha)
|
|
|
+ addcha = sorted(addcha)
|
|
|
+ for a, cha in addcha:
|
|
|
+ source.append(a)
|
|
|
+ channellist.append(cha)
|
|
|
+ print(addcha)
|
|
|
+ source = list(source)
|
|
|
+ # source.sort()
|
|
|
+ cursor = c.execute(
|
|
|
+ "SELECT modelname from STREAM where (modelname = 'helmet' or modelname = 'smoke' or modelname = 'uniform' or modelname = 'fire' or modelname = 'duty' or modelname = 'sleep' or modelname='occupancy' or modelname = 'personcar' or modelname = 'phone' or modelname = 'reflective' or modelname = 'extinguisher' or modelname = 'danager' or modelname = 'inspection' or modelname = 'cross' or modelname = 'personcount' or modelname = 'arm' or modelname = 'persontre' or modelname = 'bag' or modelname = 'fall' or modelname = 'belt' or modelname = 'clear')")
|
|
|
+ contentm = cursor.fetchall()
|
|
|
+ for m in contentm:
|
|
|
+ modellist.append(m[0])
|
|
|
+ modellist = set(modellist)
|
|
|
+ n = len(content)
|
|
|
+ print(f'modelname={n}')
|
|
|
+ print(content)
|
|
|
+ # content.reverse()
|
|
|
+ print(content)
|
xtj