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()
