def quick_sort_method():
data = request.get_json()
if data["input_tpye"] == 1 and data["operate_type"] == 0: # 生成随机数组
quick_sort = sort.Sort()
data["array_data"] = quick_sort.get_data()
elif data["input_tpye"] == 0 and data["operate_type"] == 0:
data["array_data"] = list(map(int, data["array_data"])) # 字符格式转数字
if data["operate_type"] == 1: # 排序
quick_sort = sort.Sort(data["array_data"])
data["sort_process"] = quick_sort.get_quick_sort_data()
return jsonify(data)
def main():
numbers = maker.Maker.create_array_random_int(1000, 0, 100)
print(numbers, "\n")
leet = sort.Sort()
numbers = leet.merge_sort_top_down(numbers)
print(numbers)
def face_detect_frame():
method_type = 'hog'
video_root = '/Users/alexwang/data'
video_list = ['14456458.mp4', '32974696.mp4', '16815015.mp4', '10616634.mp4']
colours = np.random.rand(32, 3) * 256 # used only for display
print('start process videos...')
for video_name in video_list:
video_tracker = sort.Sort(max_age=5)
kal = sort.KalmanBoxTracker([0, 0, 1, 1, 0])
kal.clear_count()
cap = cv2.VideoCapture(os.path.join(video_root, video_name))
frame_width = int(cap.get(3))
frame_height = int(cap.get(4))
output_path = os.path.join(video_root, 'notexpand_{}_{}'.format(method_type, video_name))
out = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'MP4V'), 15, (frame_width, frame_height))
while (cap.isOpened()):
try:
ret, frame = cap.read()
if not ret:
break
image_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
if method_type == 'cnn':
face_img_list = face_detect.cnn_face_detect(image_rgb, expand=False)
else:
face_img_list = face_detect.hog_face_detect(image_rgb, expand=False)
detections = []
for (face, rect, score) in face_img_list:
if score < 0.4:
continue
x_min, y_min, x_max, y_max = rect
detections.append([x_min, y_min, x_max, y_max, 10 * score])
print('detections:', detections)
track_bbs_ids = video_tracker.update(np.asarray(detections))
for d in track_bbs_ids:
print('d:', d)
d = d.astype(np.int32)
rectangle(frame, d[0], d[1], d[2] - d[0],
d[3] - d[1], colours[d[4] % 32, :],
thickness=2, label=str(d[4]))
cv2.imshow('image', frame)
out.write(frame)
# Exit if ESC oressed
key = cv2.waitKey(1) & 0xff
if key == 27:
sys.exit(0)
elif key == ord('q'):
break
except Exception as e:
traceback.print_exc()
cap.release()
out.release()
def dataToRGB(self, URL):
s = sort.Sort()
dataSet = sorted(glob.glob(URL), key=s.numericalSort)
RGBSet = [0] * len(dataSet)
for i in range(len(dataSet)):
dataSet[i] = cv2.imread(dataSet[i])
dataSet[i] = cv2.resize(dataSet[i], (230, 174))
RGBSet[i] = cv2.split(dataSet[i])
RGBSet = np.array(RGBSet)
print(RGBSet.shape)
return RGBSet
def detect_video(yolo, video_path, output_path=""):
import cv2
vid = cv2.VideoCapture(video_path)
if not vid.isOpened():
raise IOError("Couldn't open webcam or video")
video_FourCC = int(vid.get(cv2.CAP_PROP_FOURCC))
video_fps = vid.get(cv2.CAP_PROP_FPS)
video_size = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)))
isOutput = True if output_path != "" else False
if isOutput:
print("!!! TYPE:", type(output_path), type(video_FourCC), type(video_fps), type(video_size))
out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size)
accum_time = 0
curr_fps = 0
fps = "FPS: ??"
prev_time = timer()
mot_tracker = sort.Sort()
yolo.mot_tracker = mot_tracker
if yolo.write_to_file:
emptyFile = open(yolo.output_path + 'result.dat', 'w')
else:
emptyFile = None
while True:
return_value, frame = vid.read()
try:
image = Image.fromarray(frame)
except AttributeError:
break
image = yolo.detect_image(image, emptyFile)
result = np.asarray(image)
curr_time = timer()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
fps = "FPS: " + str(curr_fps)
curr_fps = 0
cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50, color=(255, 0, 0), thickness=2)
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
cv2.imshow("result", result)
if isOutput:
out.write(result)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if yolo.write_to_file:
emptyFile.close()
yolo.close_session()
def __init__(self, parent, *args):
self.parent = parent
# main notebook
self.root = Notebook(parent)
self.root.pack(expand=True, fill=BOTH)
self.scoutingPage = scouting.ScoutingUI(self.root)
self.pickListPage = pickList.PickList(self.root)
self.sortPage = sort.Sort(self.root)
self.root.select(0) # select the scouting page
chooseFileBtn = Button(parent,
text="Choose data folder",
command=self.getFileDir)
chooseFileBtn.pack(side=LEFT)
# set our working directory
chdir(path.dirname(__file__))
# set a reference to the current directory where we're looking for data
self.fileStrVar = StringVar()
global filedir
filedir = getcwd() + "\\files"
if len(filedir) > 20:
filedir = "..." + filedir[-17:]
self.fileStrVar.set(filedir)
Label(parent, textvariable=self.fileStrVar).pack(side=LEFT)
# selector for event
self.eventSV = StringVar()
self.eventSV.set(event)
self.eventSV.trace('w', self.onEventChange)
eventList = ["No internet connection"]
if isOnline():
eventList = list(events.keys())
eventChooser = OptionMenu(parent, self.eventSV, *eventList)
eventChooser.pack(side=RIGHT)
Label(parent, text="Event:").pack(side=RIGHT)
def __init__(self, path):
global to_file
to_file = path
try:
os.mkdir(os.path.join(os.getcwd(), "Files"))
os.mkdir(os.path.join(os.getcwd(), "CSV_Files"))
except:
pass
process = CrawlerProcess()
process.crawl(FkscrapeSpider)
process.start()
obj = sentiment.SentimentAnalysis(
os.path.join(os.getcwd(), "Files"),
os.path.join(os.getcwd(), "CSV_Files"))
obj1 = sort.Sort()
def _initialize_tracker(self):
if not self.image:
if self.tracker == 'sort':
tracker = sort.Sort()
return tracker, None
elif self.tracker == 'deepsort':
# initialize deep sort
model_filename = self.deepsort_model
encoder = gdet.create_box_encoder(model_filename, batch_size=1)
metric = nn_matching.NearestNeighborDistanceMetric(
"cosine", matching_threshold=0.5, budget=None)
tracker = deepsort_Tracker(metric)
return tracker, encoder
else:
raise ValueError(
'The variable \"tracker\" must be \"sort\" or \"deepsort\".'
)
else:
return None, None
def detect_img(yolo):
while True:
img = input('Input image filename:')
try:
image = Image.open(img)
except:
print('Open Error! Try again!')
continue
else:
# Initialization
mot_tracker = sort.Sort()
yolo.mot_tracker = mot_tracker
yolo.frame = 1
if yolo.write_to_file:
emptyFile = open(yolo.output_path + 'result.dat', 'w')
else:
emptyFile = None
r_image = yolo.detect_image(image, emptyFile)
if yolo.write_to_file:
emptyFile.close()
r_image.save(yolo.__dict__['output_path'] + 'output.png', 'png')
yolo.close_session()
def __init__(self, name):
self.max_iou_distance = rospy.get_param('max_iou_distance', 0.7)
self.max_age = rospy.get_param('max_age', 30)
self.n_init = rospy.get_param('n_init', 3)
self.metric = nn_matching.NearestNeighborDistanceMetric(
"cosine", 0.2, None)
self.tracker = Tracker(self.metric, self.max_iou_distance,
self.max_age, self.n_init)
rospy.Subscriber("image_object", ObjectArray, self.__callback1)
self.bridge = CvBridge()
self.image_sub = rospy.Subscriber("image_raw", Image,
self.__image_callback)
self.pub = rospy.Publisher('object_tracked',
ObjectArray,
queue_size=10)
self.image_pub = rospy.Publisher("object_tracked_image",
Image,
queue_size=10)
self.cv_image = None
self.visualizer = visualization.Visualization((960, 540),
update_ms=100)
self.mot_tracker = sort.Sort(iou_th=0.1)
self.seedling_id_list = []
self.seedling_lifetime = dict()
def main():
# detection result folder
detection_folder = '/media/yujiang/Data/Seedling/Experiments/counting_results_rgb/Final_model'
# video folder
video_folder = '/media/yujiang/Data/Seedling/Datasets/TestVideos'
# folder for saving counted videos
saving_folder = '/media/yujiang/Data/Seedling/Experiments/counting_videos_rgb/Final_model'
# label map
PATH_TO_LABELS = '/media/yujiang/Data/Seedling/Datasets/TFrecords/pascal_label_map.pbtxt'
NUM_CLASSES = 2 # DO NOT change this, the number of classess identified by the detection model
# Create label map
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
video_prefix_config_dict = {
'TAMU_2015': {
'iou_th':0.1, 'tracking_lifetime_th':9, 'is_transpose': False,
'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True},
'UGA_2015': {
'iou_th':0.1, 'tracking_lifetime_th':15, 'is_transpose': False,
'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True},
'UGA_2018': {
'iou_th':0.1, 'tracking_lifetime_th':9, 'is_transpose': True,
'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True}}
# Output video codec
fourcc_codec = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')
for video_prefix, counting_config in video_prefix_config_dict.items():
# tracking and counting parameters
is_transpose = counting_config['is_transpose']
iou_th = counting_config['iou_th']
tracking_lifetime_th = counting_config['tracking_lifetime_th']
resize_fx = counting_config['resize_fx']
resize_fy = counting_config['resize_fy']
output_fps = counting_config['output_fps']
is_display = counting_config['is_display']
# get testing videos with the video prefix
video_list = os.listdir(video_folder)
video_list = [f for f in video_list if f.startswith(video_prefix) and f.endswith('.mp4')]
for video_file in video_list:
video_name = video_file.split('.')[0]
detection_file_path = osp.join(detection_folder, '{0}_detection.json'.format(video_name))
video_file_path = osp.join(video_folder, video_file)
output_video_filepath = osp.join(saving_folder, '{0}.avi'.format(video_file[:-4]))
# tracking list
seedling_id_list = list()
seedling_lifetime = dict()
# load detection results
with open(detection_file_path,'r') as fid:
jstr = json.load(fid)
res_list = json.loads(jstr)
# load video for rendering tracking result
cap = cv2.VideoCapture(video_file_path)
frame_num = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
# generate output video writer
fr_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
fr_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
if is_transpose:
vd_writer = cv2.VideoWriter(output_video_filepath,
fourcc_codec, output_fps,
(int(fr_height*resize_fy), int(fr_width*resize_fx)))
else:
vd_writer = cv2.VideoWriter(output_video_filepath,
fourcc_codec, output_fps,
(int(fr_width*resize_fx), int(fr_height*resize_fy)))
# initialize the Kalman filter based tracking algorithm
mot_tracker = sort.Sort(iou_th=iou_th)
# process individual frames
for i in range(frame_num-1):
ret, frame = cap.read()
frame = cv2.resize(frame,None,fx=resize_fx, fy=resize_fy, interpolation = cv2.INTER_CUBIC)
image_np = frame
if is_transpose:
image_np = image_np.transpose((1,0,2))
# load detection result for the current frame
detection_res = res_list[i]
frame_bbox = detection_res['bbox']
frame_bbox_array = np.array(frame_bbox, dtype=np.float32)
frame_cls = detection_res['box_cls']
frame_cls = np.array([int(i) for i in frame_cls])
frame_scores = np.asarray(detection_res['box_scores']).reshape((-1,1))
if len(frame_bbox_array) != 0:
dets = np.concatenate((frame_bbox_array, frame_scores), axis=1)
else:
dets = np.array([])
# update trackers
trackers = mot_tracker.update(dets)
# update tracker names
frame_bbox_array_new = trackers[:,0:4]
frame_cls_new = list()
category_index_new = dict()
for d_index, d in enumerate(trackers[:, 4]):
if d not in seedling_id_list:
seedling_id_list.append(d)
# max_cls_id = len(seedling_id_list)
cur_d = seedling_id_list.index(d)+1
if cur_d not in list(seedling_lifetime.keys()):
seedling_lifetime[cur_d] = list()
seedling_lifetime[cur_d].append(i)
frame_cls_new.append(cur_d)
category_index_new[cur_d] = {'id':d_index, 'name':'Plant'+str(cur_d)}
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
frame_bbox_array_new,
frame_cls_new,
frame_scores,
category_index_new, # previously use 'category_index'
use_normalized_coordinates=True,
line_thickness=2)
# write to the output video
vd_writer.write(image_np)
#
if is_display is True:
cv2.imshow('video_window',image_np)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
vd_writer.release()
cv2.destroyAllWindows()
print('Processed the video {0} and saved as {1}.\n'.format(
video_file_path, output_video_filepath))
def main():
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Current device is', device)
track_data = []
images = glob(os.path.join(args.video_name, '*.jp*'))
images = sorted([item.split('/')[-1] for item in images])
threshold = 0.5
if args.gt:
print('ground truth file is', args.gt)
#ground truth represented as dictionary list by the first frame
gt = defaultdict(list)
with open(args.gt) as file:
for line in file:
#print(line)
#<frame>, <id>, <bb_left>, <bb_top>, <bb_width>, <bb_height>, <conf>, <class>, <visibility>
#print(eval(line)[0])
gt[images[eval(line)[0] - 1]].append(list(eval(line)[1:]))
#print(gt)
# get faster RCNN
#https://github.com/mlvlab/COSE474/blob/master/3_Object_Detection_and_MOT_tutorial.ipynb
#load faster R-CNN model
model = models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
model.eval()
model = model.to(device)
#print(model)
odata = OrderedDict()
i = 0
for frame in get_frames(args.video_name):
print(images[i])
start = time.time()
#change different selection threhold here for the rcnn result
odata[images[i]] = get_prediction(model, frame, device, 0.8)
i += 1
print('process time is', time.time() - start)
#tracker starts here
save_path = './results/'
mot_tracker = SORT.Sort()
img_array = []
a = 0
iou_array = []
#keep track of id
gt_track_id = {}
gt_blist = []
for key in odata.keys():
a += 1
arrlist = []
det_img = cv2.imread(os.path.join(args.video_name, key))
det_result = odata[key]
img_iou = []
if args.gt:
gt_result = gt[key]
#print(gt_result)
#print(type(gt_result))
#read in the detection results
for info in det_result:
bbox = info['bbox']
labels = info['labels']
scores = info['scores']
templist = bbox + [scores]
if labels == 'person': # label 1 is a person in MS COCO Dataset
arrlist.append(templist)
start = time.time()
track_bbs_ids = mot_tracker.update(np.array(arrlist))
#print(track_bbs_ids.shape)
print(
'frame', a, 'Association update time is {} second'.format(
round(time.time() - start, 4)))
#print(track_bbs_ids)
newname = save_path + key
#print(newname)
if args.gt:
#relate the gt_id with track id
gt_track = defaultdict(list)
#print(gt_track)
for gt_box in gt_result:
gt_label = gt_box[0]
gt_box = [
gt_box[1], gt_box[2], gt_box[1] + gt_box[3],
gt_box[2] + gt_box[4]
]
for i in range(track_bbs_ids.shape[0]):
ele = track_bbs_ids[i, :]
bbox_track = [
int(ele[0]),
int(ele[1]),
int(ele[2]),
int(ele[3])
]
temp_iou = compute_iou(bbox_track, gt_box)
if temp_iou > 0:
if gt_label in gt_track.keys():
if gt_track[gt_label][1] < temp_iou:
gt_track[gt_label] = [
int(ele[4]), temp_iou, bbox_track
]
else:
gt_track[gt_label] = [
int(ele[4]), temp_iou, bbox_track
]
#print(gt_track)
#ploting ground truth
if args.gt:
overlay = det_img.copy()
for gt_box in gt_result:
#print('gtbox type', type(gt_box))
#plot semi transparent box https://gist.github.com/IAmSuyogJadhav/305bfd9a0605a4c096383408bee7fd5c
gt_label = gt_box[0]
gt_box = [
gt_box[1], gt_box[2], gt_box[1] + gt_box[3],
gt_box[2] + gt_box[4]
]
if gt_label not in gt_track.keys():
#plot 0 iou with red shade
cv2.rectangle(overlay, (gt_box[0], gt_box[1]),
(gt_box[2], gt_box[3]), (0, 0, 255), -1)
else:
if gt_track[gt_label][1] > threshold:
if gt_label in gt_track_id.keys():
if int(gt_track_id[gt_label]) != int(
gt_track[gt_label][0]):
print('match id', gt_track_id[gt_label],
int(gt_track[gt_label][0]))
gt_blist.append(gt_label)
del gt_track_id[gt_label]
elif gt_label not in gt_track_id.keys(
) and gt_label not in gt_blist:
gt_track_id[gt_label] = gt_track[gt_label][0]
else:
pass
if gt_label not in gt_blist:
#plot over threshold with green shade
cv2.rectangle(overlay, (gt_box[0], gt_box[1]),
(gt_box[2], gt_box[3]), (0, 255, 0),
-1)
img_iou.append(gt_track[gt_label][1])
else:
cv2.rectangle(overlay, (gt_box[0], gt_box[1]),
(gt_box[2], gt_box[3]), (0, 0, 255),
-1)
#print('gt_label is', gt_label)
#print('gt_id key', gt_track_id.keys())
else:
#plot over threshold with red shade
cv2.rectangle(overlay, (gt_box[0], gt_box[1]),
(gt_box[2], gt_box[3]), (0, 0, 255), -1)
alpha = 0.3
det_img = cv2.addWeighted(overlay, alpha, det_img, 1 - alpha, 0)
#print(gt_track_id)
print(gt_blist)
for j in range(track_bbs_ids.shape[0]):
ele = track_bbs_ids[j, :]
print(ele)
bbox_track = [int(ele[0]), int(ele[1]), int(ele[2]), int(ele[3])]
track_label = str(int(ele[4]))
track_data.append([
a,
int(ele[4]),
int(ele[0]),
int(ele[1]),
int(ele[2]) - int(ele[0]),
int(ele[3]) - int(ele[1])
])
#print([a, int(ele[4]), int(ele[0]), int(ele[1]), int(ele[2])-int(ele[0]), int(ele[3]) - int(ele[1])])
#cv2.rectangle(det_img, (bbox_track[0], bbox_track[1]), (bbox_track[2], bbox_track[3]), get_color(int(ele[4])), 3)
#cv2.putText(det_img, track_label, (bbox_track[0]+5, bbox_track[1]+20), 0,0.6, (255,255,255),thickness=2)
cv2.rectangle(det_img, (bbox_track[0], bbox_track[1]),
(bbox_track[2], bbox_track[3]), (0, 255, 0), 3)
cv2.putText(det_img,
'person', (bbox_track[0] + 5, bbox_track[1] + 20),
0,
0.6, (0, 255, 0),
thickness=2)
img_array.append(det_img)
print('append')
file_name = '_'.join([args.video_name.split('/')[-2], '.txt'])
with open(file_name, 'w') as file:
for det in track_data:
print(det)
det = '{}, {}, {}, {}, {}, {}, 1, -1, -1, -1'.format(
det[0], det[1], det[2], det[3], det[4], det[5])
file.write('%s\n' % str(det))
#only compute tracked threshold
if len(img_iou) > 0:
img_iou_mean = sum(img_iou) / len(img_iou)
iou_array.append(img_iou_mean)
text = 'Frame {}: Mean IoU is {}%, {} tracked'.format(
a, round((img_iou_mean * 100), 2), len(gt_track_id))
else:
text = 'Frame {}: Mean IoU is {}%, {} tracked)'.format(
a, 0, len(gt_track_id))
print(text)
cv2.putText(det_img, text, (30, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.75,
(0, 255, 0), 2, cv2.LINE_AA)
img_array.append(det_img)
print('appending img')
'''
def main():
PATH_TO_LABELS = '/media/yujiang/Data/Seedling/Datasets/TFrecords/pascal_label_map.pbtxt'
NUM_CLASSES = 2 # DO NOT change this
detection_folder = '/media/yujiang/Data/Seedling/Experiments/counting_results_rgb/Final_model'
video_folder = '/media/yujiang/Data/Seedling/Datasets/TestVideos'
video_prefix_config_dict = {
'TAMU_2015': {
'iou_th': 0.1,
'tracking_lifetime_th': 9
},
'UGA_2015': {
'iou_th': 0.1,
'tracking_lifetime_th': 15
},
'UGA_2018': {
'iou_th': 0.1,
'tracking_lifetime_th': 9
}
}
# video_prefix_config_dict = {'UGA_2015': {'iou_th':0.1, 'tracking_lifetime_th':15}}
# Create label map
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
for video_prefix, counting_config in video_prefix_config_dict.items():
# tracking and counting parameters
iou_th = counting_config['iou_th']
tracking_lifetime_th = counting_config['tracking_lifetime_th']
# video list
video_list = os.listdir(video_folder)
video_list = [
f for f in video_list
if f.startswith(video_prefix) and f.endswith('.mp4')
]
for video_file in video_list:
video_name = video_file.split('.')[0]
detection_file_path = osp.join(
detection_folder, '{0}_detection.json'.format(video_name))
video_file_path = osp.join(video_folder, video_file)
# tracking list
seedling_id_list = list()
seedling_lifetime = dict()
# load detection results
with open(detection_file_path, 'r') as fid:
jstr = json.load(fid)
res_list = json.loads(jstr)
cap = cv2.VideoCapture(video_file_path)
frame_num = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
cap.release()
# initialize the Kalman filter based tracking algorithm
mot_tracker = sort.Sort(iou_th=iou_th)
total_time = 0
for i in range(frame_num - 1):
# detection result for the current frame
detection_res = res_list[i]
frame_bbox = detection_res['bbox']
frame_bbox_array = np.array(frame_bbox, dtype=np.float32)
frame_cls = detection_res['box_cls']
frame_cls = np.array([int(i) for i in frame_cls])
frame_scores = np.asarray(
detection_res['box_scores']).reshape((-1, 1))
if len(frame_bbox_array) != 0:
dets = np.concatenate((frame_bbox_array, frame_scores),
axis=1)
else:
dets = np.array([])
start_time = time.time()
# update trackers based on the current detection result
trackers = mot_tracker.update(dets)
cycle_time = time.time() - start_time
# update the total time used
total_time += cycle_time
# update the tracker list
for d_index, d in enumerate(trackers[:, 4]):
if d not in seedling_id_list:
seedling_id_list.append(d)
# max_cls_id = len(seedling_id_list)
cur_d = seedling_id_list.index(d) + 1
if cur_d not in list(seedling_lifetime.keys()):
seedling_lifetime[cur_d] = list()
seedling_lifetime[cur_d].append(i)
# identify valid seedling trackers
valid_seedling_tracker_list = list()
for k, v in seedling_lifetime.items():
if len(v) >= tracking_lifetime_th:
valid_seedling_tracker_list.append(k)
print('Video {0} has {1} seedlings using {2} seconds.\n'.format(
video_file, len(valid_seedling_tracker_list), total_time))
# cap = cv2.VideoCapture('/media/yujiang/HTP-2017/Cotton/2018/ENGR/20180613/ENGR1_1_19.MOV')
# generate output video writer
fr_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
fr_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
def SORT(self, predictions):
qtt_frames = len(predictions)
tracker = sort.Sort()
tracked_vehicles_trajectory = {} # Trajetória de cada ID identificado
vehicles_on_the_frame = {} # Veículos que estão presentes no frame X
mot_labels = [[0, 0, 0, 0, 0, 0, 0] for _ in range(qtt_frames + 1)]
for frame_number in range(1, qtt_frames+1):
bboxes_atual = predictions[frame_number][:]
# Formatar a lista para alimentar o Sort
# np.array( [ [x1,y1,x2,y2,score1], [x3,y3,x4,y4,score2], ... ] )
if len(bboxes_atual) == 0:
bboxes_atual = np.zeros((0, 5)) # Requerido pelo Algoritmo Sort
else:
for idx in range(len(bboxes_atual)):
x1, y1, w, h, classe = bboxes_atual[idx][1:]
x2 = x1 + w
y2 = y1 + h
score = np.random.randint(50, 100)/100 # Temporariamente setar score como random.
bboxes_atual[idx] = [x1, y1, x2, y2, score, classe]
# Numpy array requerido pelo Sort
bboxes_atual = np.array(bboxes_atual)
#last_col = bboxes_atual[:, -1]
#find_rows = lambda classe: bboxes_atual[last_col == classe].copy()
#bboxes_cars = find_rows(1)
#bboxes_truck = find_rows(2)
#bboxes_bus = find_rows(3)
# Analisar o frame atual e identificar os bounding boxes id (update SORT)
track_bbs_ids = tracker.update(bboxes_atual[:,:-1])
this_frame_ids = track_bbs_ids[:,-1]
#track_bbs_ids_cars = tracker_car.update(bboxes_cars)
#track_bbs_ids_truck = tracker_truck(bboxes_truck)
#track_bbs_ids_bus = tracker_bus(bboxes_bus)
# Passar as coordenadas para o padrão: [frame,x,y,w,h,idx]
newboxes_list = [[0,0,0,0,0,0,0] for _ in range(len(track_bbs_ids))]
for i, newbox in enumerate(track_bbs_ids):
x1,y1,x2,y2,idx = newbox
x, y, w, h = x1, y1, abs(x2-x1), abs(y2-y1)
x,y,w,h,idx = int(x), int(y), int(w), int(h), int(idx)
newboxes_list[i] = [frame_number, x, y, w, h, classe, idx]
# Guardar a trajetória do centro do veículo IDx
xc, yc = int(x + w/2) , int(y + h/2)
if idx in tracked_vehicles_trajectory:
tracked_vehicles_trajectory[idx].append((frame_number,xc,yc))
else:
tracked_vehicles_trajectory[idx] = [(frame_number,xc,yc)]
# Atualizar a variável global
vehicles_on_the_frame[frame_number] = this_frame_ids
mot_labels[frame_number] = newboxes_list[:]
return mot_labels, tracked_vehicles_trajectory, vehicles_on_the_frame
total_time = 0.0
total_frames = 0
#Read detections file
with open('detection-3.json') as json_file:
json_data = json.load(json_file)
detections = []
for key in json_data:
for det in json_data[key]:
detection = [int(key), -1, *(det['bbox']), det['score'], -1, -1, -1]
detections.append(detection)
#Convert to Numpy array
detections = np.asarray(detections)
mot_tracker = sort.Sort()
result_tracking = []
print("Processing ")
for frame in range(int(detections[:, 0].max())):
frame += 1
#dets = seq_dets[seq_dets[:,0]==frame,2:7]
dets = detections[detections[:, 0] == frame, 2:7]
dets[:, 2:4] += dets[:, 0:2] #convert to [x1,y1,w,h] to [x1,y1,x2,y2]
total_frames += 1
start_time = time.time()
trackers = mot_tracker.update(dets)
cycle_time = time.time() - start_time
total_time += cycle_time
for d in trackers:
# -----------------------------------------------------------------------------|
# -----------------------------------------------------------------------------|
def list_is_same(some_list, other_list):
"""
Checks if a list is same as other
"""
return some_list == other_list
# -----------------------------------------------------------------------------|
# Create random list
some_random_list = []
my_sort = sort.Sort()
for iteration in range(20000):
random_number = random.randint(0, 2000)
some_random_list.append(random_number)
my_random_list = some_random_list[:]
print("List was", my_random_list)
# ---------------------------------------------------------------------------- #
# Insertion sort test
# ---------------------------------------------------------------------------- #
start = time.time()
my_sorted_list = my_sort.insertion_sort(my_random_list)
end = time.time()
import sort
jysSort = sort.Sort()
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.bubble_sort(collection)
print('Bubble Sort: ', collection)
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.insertion_sort(collection)
print('Insertion Sort:', collection)
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.selection_sort(collection)
print('Selection Sort:', collection)
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.heap_sort(collection)
print('Heap Sort: ', collection)
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.quick_sort(collection)
print('Quick Sort: ', collection)
collection = [9, 2, 5, 7, 1, 3, 4, 8, 6, 10]
jysSort.merge_sort(collection)
print('Merge Sort: ', collection)
