def get_model(cls, model_path='../model'): #本当は引数でモデルパスを渡したい cls.cyolo = CYOLO() cls.pyolo = PYOLO() # Definition of the parameters for Car Cmax_cosine_distance = 0.3 Cnn_budget = None cls.Cnms_max_overlap = 1.0 # Definition of the parameters for Pedestrian Pmax_cosine_distance = 0.3 Pnn_budget = None cls.Pnms_max_overlap = 0.8 # Deep SORT model_filename = '../model/mars-small128.pb' cls.cencoder = gdet.create_box_encoder(model_filename, batch_size=1) cls.pencoder = gdet.create_box_encoder(model_filename, batch_size=1) cmetric = nn_matching.NearestNeighborDistanceMetric( "cosine", Cmax_cosine_distance, Cnn_budget) pmetric = nn_matching.NearestNeighborDistanceMetric( "cosine", Pmax_cosine_distance, Pnn_budget) cls.ctracker = Tracker(cmetric) cls.ptracker = Tracker(pmetric) cls.tracking = True cls.writeVideo_flag = True #推論したいカテゴリを設定 cls.cl_list = ['Car', 'Pedestrian'] return True
def main(mask_rcnn): filename = sys.argv[1] # Definition of the parameters max_cosine_distance = 0.01 nn_budget = None # deep_sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) tracker = Tracker(metric) reader = imageio.get_reader(filename, "ffmpeg") fps = reader.get_meta_data()['fps'] N = len(reader) - 1 writer = imageio.get_writer("output/" + get_filename(filename), fps=fps) try: for i, frame in tqdm(enumerate(reader), desc="Frames ", total=N): frame, tracker, encoder = detect(frame, tracker, encoder, mask_rcnn, threshold=0.95) writer.append_data(frame) finally: writer.close()
def __init__(self, stream, queue, track_prefix="", simulation_file=None): multiproc.context.Process.__init__(self) self.queue = queue self.track_prefix = track_prefix if simulation_file is None: # Definition of the parameters max_cosine_distance = 0.5 # Initialize deepsort model_filename = 'networks//mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", max_cosine_distance, None) # Initialize Object Detector and Tracker video_width = int(stream.get(cv2.CAP_PROP_FRAME_WIDTH)) # float video_height = int(stream.get(cv2.CAP_PROP_FRAME_HEIGHT)) detector = Detector(video_width, video_height) self.tracker = Tracker(metric, detector, encoder) self.stream = stream self.run = self.track else: self.simulation_file = simulation_file self.run = self.simulate
def __init__(self, weightPath="/yolov4_sb_best.weights", configPath="/yolov4_sb.cfg", metaPath="/voc_sb.data", deepsort_modelPath="/mars_sb_14.pb", image_size=640, nms_conf_thresh=0.4, nms_iou_thresh=0.5,max_cosine_distance = 0.6, nn_budget = 50, nms_max_overlap = 1.0): try: import darknet from deep_sort.tracker import Tracker from deep_sort import nn_matching from tools import generate_detections as gdet from deep_sort import preprocessing from deep_sort.detection import Detection as deep_detection import os except ImportError: raise self.image_size = image_size project_dir = os.path.dirname(__file__) configPath = os.path.join(project_dir, configPath) weightPath = os.path.join(project_dir, weightPath) metaPath = os.path.join(project_dir, metaPath) deepsort_modelPath = os.path.join(project_dir, deepsort_modelPath) self.network, self.class_names, self.class_colors = darknet.load_network(configPath, metaPath, weightPath, batch_size=1) self.nms_max_overlap = nms_max_overlap #DarknetImage self.darknet = darknet ww = 640 hh = 480 self.darknet_image = darknet.make_image(ww, hh, 3) # deep_sort self.preprocessing = preprocessing self.deep_detection = deep_detection self.encoder = gdet.create_box_encoder(deepsort_modelPath, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) self.tracker = Tracker(metric) BaseDetectionServer.__init__(self)
def __init__(self, debug = False): #from openpose import * params = dict() params["logging_level"] = 3 params["output_resolution"] = "-1x-1" params["net_resolution"] = "160x160" params["model_pose"] = "BODY_25" params["alpha_pose"] = 0.6 params["scale_gap"] = 0.3 params["scale_number"] = 1 params["render_threshold"] = 0.05 params["num_gpu_start"] = 0 params["disable_blending"] = False # Ensure you point to the correct path where models are located params["default_model_folder"] = Constants.PATH + "/models/" self.openpose = OpenPose(params) max_cosine_distance = Constants.max_cosine_distance nn_budget = Constants.nn_budget self.nms_max_overlap = Constants.nms_max_overlap max_age = Constants.max_age n_init = Constants.n_init model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(model_filename,batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) self.tracker = DeepTracker(metric, max_age = max_age,n_init= n_init) self.capture = cv2.VideoCapture(0) if self.capture.isOpened(): # Checks the stream self.frameSize = (int(self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(self.capture.get(cv2.CAP_PROP_FRAME_WIDTH))) Constants.SCREEN_HEIGHT = self.frameSize[0] Constants.SCREEN_WIDTH = self.frameSize[1]
def __init__(self, name, metric, yolo_interface, model_filename, \ nms_max_overlap, image_sub, image_pub, detected_pub): # Set the shutdown function (stop the robot) # rospy.on_shutdown(self.shutdown) self.name = name self._cv_bridge = CvBridge() self._max_overlap = nms_max_overlap # deep_sort self._encoder = gdet.create_box_encoder(model_filename, batch_size=1) self._tracker = Tracker(metric) self._yolo_interface = yolo_interface self._fps = 0.0 self._image_sub = rospy.Subscriber(image_sub, ROSImage, self.image_callback, queue_size=1) # self.thermal_sub = rospy.Subscriber(THERMAL_TOPIC, ROSImage, self.thermal_callback, queue_size=1) self._image_pub = rospy.Publisher(image_pub, ROSImage, queue_size=1) self._detected_pub = rospy.Publisher(detected_pub, DetectedFull, queue_size=1) # self._cv_image = None self._image_msg = None self._image_updated = False self.thread = threading.Thread(target=self.process, name=name) # self.lock = lock rospy.loginfo('##################### ' + name + ' Initialization Finished! #####################')
def init(vid): global tracker, encoder, nms_max_overlap, width, height, fps, codec, out nms_max_overlap = 1.0 max_cosine_distance = 0.4 nn_budget = None # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) encoder = gdet.create_box_encoder('model_data/mars-small128.pb', batch_size=1) out = None # get video ready to save locally if flag is set if FLAGS.output: # by default VideoCapture returns float instead of int width = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)) height = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)) fps = int(vid.get(cv2.CAP_PROP_FPS)) codec = cv2.VideoWriter_fourcc(*FLAGS.output_format) out = cv2.VideoWriter(FLAGS.output, codec, fps, (width, height))
def __init__(self, net, hyp): self.encoder = gen.create_box_encoder(net, batch_size=1) self.metric = nn.NearestNeighborDistanceMetric( "cosine", hyp['max_cosine_distance'], hyp['nn_budget']) self.tracker = LbTracker(self.metric) self.min_conf = hyp['min_conf'] self.info = None
def __init__(self): # Definition of the parameters self.max_cosine_distance = 0.5 self.nn_budget = None self.nms_max_overlap = 1.0 #initialize deep sort self.model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(self.model_filename, batch_size=1) self.metric = nn_matching.NearestNeighborDistanceMetric( "cosine", self.max_cosine_distance, self.nn_budget) self.tracker = Tracker(self.metric) self.physical_devices = tf.config.experimental.list_physical_devices( 'GPU') if len(self.physical_devices) > 0: tf.config.experimental.set_memory_growth(self.physical_devices[0], True) if FLAGS.tiny: self.yolo = YoloV3Tiny(classes=FLAGS.num_classes) else: self.yolo = YoloV3(classes=FLAGS.num_classes) self.yolo.load_weights(FLAGS.weights) logging.info('weights loaded') self.class_names = [c.strip() for c in open(FLAGS.classes).readlines()] logging.info('classes loaded') self.fps = 0.0 self.last_tracked = []
def __init__(self, debug=False): #from openpose import * params = dict() params["model_folder"] = Constants.openpose_modelfolder params["net_resolution"] = "-1x320" self.openpose = op.WrapperPython() self.openpose.configure(params) self.openpose.start() max_cosine_distance = Constants.max_cosine_distance nn_budget = Constants.nn_budget self.nms_max_overlap = Constants.nms_max_overlap max_age = Constants.max_age n_init = Constants.n_init model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", max_cosine_distance, nn_budget) self.tracker = DeepTracker(metric, max_age=max_age, n_init=n_init) # self.capture = cv2.VideoCapture('D:/walk_tour-edit.mp4') self.capture = cv2.VideoCapture('D:/walk_tour.mp4') if self.capture.isOpened(): # Checks the stream self.frameSize = (int(self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT)), int(self.capture.get(cv2.CAP_PROP_FRAME_WIDTH))) Constants.SCREEN_HEIGHT = self.frameSize[0] Constants.SCREEN_WIDTH = self.frameSize[1] self.cnt = 1
def __init__(self, ConfigProto, InteractiveSession, FLAGS): print(f"{Back.GREEN}YOLO init...{Style.RESET_ALL}") self.config = ConfigProto() self.config.gpu_options.allow_growth = True self.session = InteractiveSession(config=self.config) """ setup yolov4-tiny model """ self.yolo_interpreter = tf.lite.Interpreter( model_path=FLAGS.detector_weights) self.yolo_interpreter.allocate_tensors() self.input_details = self.yolo_interpreter.get_input_details() self.output_details = self.yolo_interpreter.get_output_details() self.input_size = FLAGS.size # image resizing self.iou = FLAGS.iou self.score = FLAGS.score """ setup DeepSORT model """ self.encoder = gdet.create_box_encoder(FLAGS.tracker_weights, batch_size=1) self.metric = nn_matching.NearestNeighborDistanceMetric( "cosine", FLAGS.max_cosine_distance, FLAGS.nn_budget) # calculate cosine distance metric self.DeepSORT_tracker = Tracker(self.metric) # initialize tracker self.count = FLAGS.count self.info = FLAGS.info self.dont_show = FLAGS.dont_show self.nms_max_overlap = FLAGS.nms_max_overlap
def main(yolo): nms_max_overlap = 1.0 # deep_sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) video_capture = cv2.VideoCapture(0) ret, frame = video_capture.read() # frame shape 640*480*3 image = Image.fromarray(frame[..., ::-1]) #bgr to rgb boxs = yolo.detect_image(image) features = encoder(frame, boxs) print(features) for count, feature in enumerate(features): #create new 2d arrays for each individual box_arr = [boxs[count]] feat_arr = [feature] detections = [ Detection(bbox, 1.0, feat) for bbox, feat in zip(box_arr, feat_arr) ] # Run non-maxima suppression. gets rid of annoying overlapping BB's that are likely the same object boxes = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) indices = preprocessing.non_max_suppression(boxes, nms_max_overlap, scores) detections = [detections[i] for i in indices] for det in detections: bbox = det.to_tlbr() cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (255, 0, 0), 2) #output frame cv2.startWindowThread() cv2.namedWindow("preview") cv2.imshow("preview", frame) cv2.waitKey(2000) cv2.imwrite("pic" + str(count) + ".jpg", frame) #write individual feature vectors to pickle files pickle_out = open("pickledump" + str(count) + ".pickle", "wb") cPickle.dump(feature, pickle_out) pickle_out.close() #read and print pickled feature vectors pickle_in = open("pickledump" + str(count) + ".pickle", "rb") ret = cPickle.load(pickle_in) print(ret) video_capture.release() cv2.destroyAllWindows()
def Setup(self): self.encoder, self.sess = create_box_encoder(DEEPSORT_MODEL, batch_size=16) self.clipper_model_name = 'tracking-reid' self.clipper_conn = register( model_name=self.clipper_model_name, sess=self.sess, func=self.run_session, ) self.log('init')
def init_deepsort(max_cosine_distance, nn_budget): model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) return encoder, tracker
def __init__(self, config): self.config = config self.lines = self._create_lines(config.lines) self.human_detector = YOLO(**config.human_detector) self.human_class_name = "person" self.tracker = self._create_tracker(config.tracker) self.features_encoder = generate_detections.create_box_encoder( config.tracker.deepsort_model_path, batch_size=1) self.previous_tracks_positions = LimitedSizeDict( size_limit=config.lines_crossing_detector.history_size)
def main(mask_rcnn): filename = sys.argv[1] # Definition of the parameters max_cosine_distance = 0.3 nn_budget = None nms_max_overlap = 1.0 # deep_sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) tracker = Tracker(metric) reader = imageio.get_reader(filename, "ffmpeg") fps = reader.get_meta_data()['fps'] N = len(reader) - 1 writer = imageio.get_writer("output/" + get_filename(filename), fps=fps) try: for i, frame in tqdm(enumerate(reader), desc="Frames ", total=N): masks = mask_rcnn.detect_people(frame) masks = image_utils.classify_masks_with_hash(masks) boxs = masks.get_xywh() # print("box_num",len(boxs)) features = encoder(frame, boxs) # score to 1.0 here). detections = [ Detection(mask.xywh, mask.score, feature, mask.kmeans_label) for mask, feature in zip(masks, features) ] # Run non-maxima suppression. boxes = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) indices = preprocessing.non_max_suppression( boxes, nms_max_overlap, scores) #TODO: with maskrcnn, this may not be required detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections) image_utils.draw_player_with_tracks(frame, tracker.tracks) writer.append_data(frame) finally: writer.close()
def __init__(self, yolo, video_path, save_path="result", sample_frequency=50, caffe_confidence=0.5, max_face_sample_count=20, max_object_life=50, show_process=True): # 人脸采样参数 self.sample_frequency = sample_frequency # 人脸采样n帧每次 self.caffe_confidence = caffe_confidence # 人脸最小置信度 self.max_face_sample_count = max_face_sample_count # 人脸最大采样数量 self.max_object_life = max_object_life # 对象n帧仍未出现视为消失 # caffe模型 self.caffe_model_Path = "model_data/deploy.prototxt.txt" self.caffe_weight_Path = "model_data/res10_300x300_ssd_iter_140000.caffemodel" # Deep Sort参数 self.max_cosine_distance = 0.3 self.nn_budget = None self.nms_max_overlap = 1.0 # 深度关联度量算法[多目标跟踪算法](Deep Sort) self.model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(self.model_filename,batch_size=1) self.metric = nn_matching.NearestNeighborDistanceMetric("cosine", self.max_cosine_distance, self.nn_budget) self.tracker = Tracker(self.metric) # 杂项参数 self.yolo = yolo self.video_path = video_path self.show_process = show_process self.frame_index = -1 self.fps=0.0 # 初始化 # 创建存储文件夹 if not os.path.exists(save_path): os.mkdir(save_path) self.write_path = os.path.join(save_path,os.path.splitext(os.path.basename(self.video_path))[0]) if not os.path.exists(self.write_path): os.mkdir(self.write_path) self.video_capture = cv2.VideoCapture(self.video_path) self.detect = Detector(self.max_object_life, self.max_face_sample_count, self.caffe_confidence, self.write_path, self.caffe_model_Path, self.caffe_weight_Path, self.sample_frequency) # 运行时参数 self.frame_count = int(self.video_capture.get(7)) self.show_freq = int(0.01 * self.frame_count) # self.process = 0 ### 测试仿真 self.times = [] self.fpss = [] self.indexs = []
def main(yolo): # Definition of the parameters max_cosine_distance = 0.3 nn_budget = None nms_max_overlap = 1.0 # deep_sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename,batch_size=1) video_capture = cv2.VideoCapture('http://192.168.43.202:8000/stream.mjpg') fps = 0.0 while True: ret, frame = video_capture.read() # frame shape 640*480*3 if ret != True: break; t1 = time.time() image = Image.fromarray(frame) boxs,scores,classes = yolo.detect_image(image) # print("box_num",len(boxs)) features = encoder(frame,boxs) # score to 1.0 here). detections = [Detection(bbox, score, feature , dclass) for bbox, feature, score, dclass in zip(boxs, features, scores, classes)] # Run non-maxima suppression. boxes = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) indices = preprocessing.non_max_suppression(boxes, nms_max_overlap, scores) detections = [detections[i] for i in indices] c, addr = s.accept() # Establish connection with client. print ('Got connection from', addr) for det in detections: print(det.dclass) c.sendall(b'obstruction') break c.close() # Close the connection fps = ( fps + (1./(time.time()-t1)) ) / 2 print("fps= %f"%(fps)) # Press Q to stop! if cv2.waitKey(1) & 0xFF == ord('q'): break video_capture.release() cv2.destroyAllWindows()
def __init__(self): # loading this encoder is slow, should be done only once. parser = configparser.ConfigParser() _ = parser.read("configs/global.cfg") self.deepsort_model = parser.get("Deepsort", "model_path") # print(self.deepsort_model) self.encoder = generate_detections.create_box_encoder( "/home/rbccps/projects/VisTraSAS/models/mars-small128.pb") # print("The model has been loaded") self.metric = nn_matching.NearestNeighborDistanceMetric( "cosine", .5, 100) self.tracker = Tracker(self.metric)
def __init__(self): self.y_axis = -1 self.clickFlag = False self.max_cosine_distance = 0.5 nn_budget = None self.nms_max_overlap = 1.0 model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", self.max_cosine_distance, nn_budget) self.tracker = Tracker(metric)
def __init__(self, max_age=30): self.logger = get_logger(self) max_cosine_distance = 0.3 nn_budget = None self.nms_max_overlap = 1.0 model_filename = 'model_data/mars-small128.pb' self.encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", max_cosine_distance, nn_budget) self.tracker = Tracker(metric, max_age=max_age)
def deep_sort(): # Definition of the parameters max_cosine_distance = 0.3 nn_budget = None nms_max_overlap = 1.0 # deep_sort model_filename = 'model/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) tracker = Tracker(metric) return tracker, encoder, nms_max_overlap
def __init__(self, weights='weights/yolov3.tf', labels_file='data/coco.names', image_size=416, score_threshold=0, filter=None): self.class_names = [c.strip() for c in open(labels_file).readlines()] self.yolo = YoloV3(classes=len(self.class_names)) self.yolo.load_weights(weights) self.image_size = image_size self.score_threshold = score_threshold self.encoder = gdet.create_box_encoder('model_data/mars-small128.pb', batch_size=1)
def main(_argv): # Definition of the parameters max_cosine_distance = 0.5 nn_budget = None nms_max_overlap = 0.8 counter = [] # initialize deep sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) # calculate cosine distance metric metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) # initialize tracker tracker = Tracker(metric) # load configuration for object detector config = ConfigProto() config.gpu_options.allow_growth = True input_size = FLAGS.size # load tflite model if flag is set if FLAGS.framework == 'tflite': interpreter = tf.lite.Interpreter(model_path=FLAGS.weights) interpreter.allocate_tensors() input_details = interpreter.get_input_details() output_details = interpreter.get_output_details() print(input_details) print(output_details) # otherwise load standard tensorflow saved model else: saved_model_loaded = tf.saved_model.load(FLAGS.weights, tags=[tag_constants.SERVING]) infer = saved_model_loaded.signatures['serving_default'] print('setup done') frame_queue = Queue() darknet_image_queue = Queue(maxsize=1) detections_queue = Queue(maxsize=1) fps_queue = Queue(maxsize=1) threading.Thread(target=get_stream, args=(frame_queue, darknet_image_queue)).start() threading.Thread(target=do_inference, args=(darknet_image_queue, detections_queue, fps_queue, frame_queue, encoder, nms_max_overlap, tracker, counter, infer)).start() threading.Thread(target=display, args=(frame_queue, fps_queue, detections_queue)).start()
def load_model(): # set thread max_cosine_distance = 0.3 nn_budget = None nms_max_overlap = 1.0 #1.0 # model of tracker model_filename = 'MODELS/TRACK_PERSON/model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) #metric = nn_matching.NearestNeighborDistanceMetric("euclidean", max_cosine_distance, nn_budget) tracker = Tracker(metric) return tracker, encoder
def __init__(self, featmodel, cap_num, num): self.cap_num = cap_num self.yolo = YOLO() self.encoder = gdet.create_box_encoder(featmodel, batch_size=1) self.time = 1.0/(30.0/num-1) self.alltrackers = [] self.preframe = {} self.velo = {} for i in range(cap_num): metric = nn_matching.NearestNeighborDistanceMetric("cosine", Params.max_cosine_distance, Params.nn_budget) self.alltrackers.append(Tracker(metric)) self.preframe.update({i:[]}) self.velo.update({i:[]}) print(self.preframe, self.time)
def __init__(self, config_path, service_name, image_height=480, image_width=640, image_hz=30, deepsort_modelPath="/mars_sb_14.pb", max_cosine_distance=0.6, nn_budget=50, nms_max_overlap=1.0): try: import modularmot from modularmot.utils import ConfigDecoder from deep_sort.tracker import Tracker from deep_sort import nn_matching from tools import generate_detections as gdet from deep_sort import preprocessing from deep_sort.detection import Detection as deep_detection import os except ImportError: raise with open(config_path) as cfg_file: config = json.load(cfg_file, cls=ConfigDecoder) project_dir = os.path.dirname(__file__) deepsort_modelPath = os.path.join(project_dir, deepsort_modelPath) self.nms_max_overlap = nms_max_overlap #Image Info self.image_height = image_height self.image_width = image_width print("Load Engine") self.mot = modularmot.MOT( [int(image_width), int(image_height)], 1.0 / int(image_hz), config['mot'], detections_only=True, verbose=False) # deep_sort self.preprocessing = preprocessing self.deep_detection = deep_detection self.encoder = gdet.create_box_encoder(deepsort_modelPath, batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", max_cosine_distance, nn_budget) self.tracker = Tracker(metric) self.currently_busy = Event() # Base class must be called at the end due to self.service_server.spin() BaseDetectionServer.__init__(self, service_name=service_name)
def __init__(self, args): self.args = args # Initialise camera & camera viewport self.init_camera() # Initialise output self.init_output(self.args.output) # Initialise object detector (for some reason it has to happen # here & not within detect_objects(), or else the inference engine # gets upset and starts throwing NaNs at me. Thanks, Python.) self.object_detector = SSD_MOBILENET(wanted_label='person', model_file=self.args.model, label_file=self.args.labels, num_threads=self.args.num_threads, edgetpu=self.args.edgetpu) # Initialise feature encoder if self.args.encoder_model is None: model_filename = '{}/mars-64x32x3.pb'.format( self.args.deepsorthome) else: model_filename = self.args.encoder_model self.encoder = gdet.create_box_encoder( model_filename, batch_size=self.args.encoder_batch_size) self.background_subtraction = not self.args.disable_background_subtraction # Initialise tracker nn_budget = None metric = nn_matching.NearestNeighborDistanceMetric( "cosine", self.args.max_cosine_distance, nn_budget) self.tracker = Tracker(metric, max_iou_distance=self.args.max_iou_distance, max_age=self.args.max_age) # Initialise database self.db = {} self.delcount = 0 self.intcount = 0 self.poscount = 0 self.negcount = 0 self.mqtt = None self.topic = self.args.mqtt_topic self.mqtt_acp_id = self.args.mqtt_acp_id self.heartbeat_delay_secs = self.args.heartbeat_delay_secs self.loop = asyncio.get_event_loop()
def __init__(self): self.yolo = YOLO() self.max_cosine_distance = 0.3 self.nn_budget = None self.nms_max_overlap = 1.0 self.encoder = gdet.create_box_encoder('model_data/mars-small128.pb', batch_size=1) self.tracker = Tracker( nn_matching.NearestNeighborDistanceMetric("cosine", self.max_cosine_distance, self.nn_budget)) self.dqs = [deque() for _ in range(9999)] self.poly = [] self.id_cnt_dict = {} self.queue_dict = {}
def __init__(self, timesteps=32): self.active_actors = [] self.inactive_actors = [] self.actor_no = 0 self.frame_history = [] self.frame_no = 0 self.timesteps = timesteps self.actor_infos = {} # deep sort self.encoder = create_box_encoder(MODEL_CKPT, batch_size=16) metric = nn_matching.NearestNeighborDistanceMetric( "cosine", 0.2, None) #, max_cosine_distance=0.2) #, nn_budget=None) #self.tracker = ds_Tracker(metric, max_iou_distance=0.7, max_age=30, n_init=3) self.tracker = ds_Tracker(metric, max_iou_distance=0.7, max_age=200, n_init=1) self.score_th = 0.40
def main(yolo): # Definition of the parameters max_cosine_distance = 0.3 nn_budget = None nms_max_overlap = 1.0 # deep_sort model_filename = 'model_data/mars-small128.pb' encoder = gdet.create_box_encoder(model_filename,batch_size=1) metric = nn_matching.NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget) tracker = Tracker(metric) writeVideo_flag = True video_capture = cv2.VideoCapture(0) if writeVideo_flag: # Define the codec and create VideoWriter object w = int(video_capture.get(3)) h = int(video_capture.get(4)) fourcc = cv2.VideoWriter_fourcc(*'MJPG') out = cv2.VideoWriter('output.avi', fourcc, 15, (w, h)) list_file = open('detection.txt', 'w') frame_index = -1 fps = 0.0 while True: ret, frame = video_capture.read() # frame shape 640*480*3 if ret != True: break; t1 = time.time() image = Image.fromarray(frame) boxs = yolo.detect_image(image) # print("box_num",len(boxs)) features = encoder(frame,boxs) # score to 1.0 here). detections = [Detection(bbox, 1.0, feature) for bbox, feature in zip(boxs, features)] # Run non-maxima suppression. boxes = np.array([d.tlwh for d in detections]) scores = np.array([d.confidence for d in detections]) indices = preprocessing.non_max_suppression(boxes, nms_max_overlap, scores) detections = [detections[i] for i in indices] # Call the tracker tracker.predict() tracker.update(detections) for track in tracker.tracks: if track.is_confirmed() and track.time_since_update >1 : continue bbox = track.to_tlbr() cv2.rectangle(frame, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])),(255,255,255), 2) cv2.putText(frame, str(track.track_id),(int(bbox[0]), int(bbox[1])),0, 5e-3 * 200, (0,255,0),2) for det in detections: bbox = det.to_tlbr() cv2.rectangle(frame,(int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])),(255,0,0), 2) cv2.imshow('', frame) if writeVideo_flag: # save a frame out.write(frame) frame_index = frame_index + 1 list_file.write(str(frame_index)+' ') if len(boxs) != 0: for i in range(0,len(boxs)): list_file.write(str(boxs[i][0]) + ' '+str(boxs[i][1]) + ' '+str(boxs[i][2]) + ' '+str(boxs[i][3]) + ' ') list_file.write('\n') fps = ( fps + (1./(time.time()-t1)) ) / 2 print("fps= %f"%(fps)) # Press Q to stop! if cv2.waitKey(1) & 0xFF == ord('q'): break video_capture.release() if writeVideo_flag: out.release() list_file.close() cv2.destroyAllWindows()