def _main_(args): config_path = args.conf image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_width=config['model']['input_width'], input_height=config['model']['input_height'], input_channel=config['model']['input_channel'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors'], saved_config_name=config['train']['saved_config_name']) ############################### # Load trained weights ############################### print(config['train']['saved_weights_name']) yolo.load_weights(config['train']['saved_weights_name']) ############################### # Predict bounding boxes ############################### if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(): config_path = 'config.json' weights_path = 'pre_train_model.h5' image_path = 'sample_example/PartA_00640.jpg' with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend = config['model']['backend'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(boxes) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend = config['model']['backend'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### start = time.time() yolo = YOLO(backend = config['model']['backend'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) print('Finish making model, using time: ',round(time.time()-start,3)) ############################### # Load trained weights ############################### start = time.time() yolo.load_weights(weights_path) print('Finish loading weights, using time: ',round(time.time()-start,3)) ############################### # Predict bounding boxes ############################### start = time.time() if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print('Finish predicting, using time: ',round(time.time()-start,3)) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def main(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) # build model yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) # load pretrained model print(weights_path) yolo.load_weights(weights_path) # predict bounding box if image_path[-4:] == '.mp4': input_file = os.path.basename(args.input) video_out = args.output + config['model']['architecture'].replace( " ", "") + "_" + input_file[:-4] + ".mp4" video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 30.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() # boxes is list of box. normalize to 0~1 with input shape # box.x: xmin, box.y: ymin, box.w: box width, box.h: box height boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') input_file = os.path.basename(args.input) cv2.imwrite(args.output + config['model']['architecture'].replace(" ", "") + "_" + input_file[:-4] + ".png")
class YOLO(): def __init__(self, yaml_fp): yf_ = open(yaml_fp, 'r') yaml_ = yaml.load(yf_) config_path = yaml_['config_path'] weights_path = yaml_['weights_path'] self._score = yaml_['score'] self._nms = yaml_['nms'] yf_.close() os.chdir(config_path[:config_path.rfind('/') + 1]) with open(config_path) as config_buffer: self._config = json.load(config_buffer) self._yolo = YOLO_( backend=self._config['model']['backend'], input_size=self._config['model']['input_size'], labels=self._config['model']['labels'], max_box_per_image=self._config['model']['max_box_per_image'], anchors=self._config['model']['anchors']) self._yolo.load_weights(weights_path) self._labels = self._config['model']['labels'] # for some reason, need to run once here from numpy import empty esz_ = [ self._config['model']['input_size'], self._config['model']['input_size'], 3 ] self.detect_img(empty(esz_)) print(' YOLO object initialized!') def detect_img(self, img): boxes_ = self._yolo.predict(img, self._score, self._nms) msgs_ = [] for box in boxes_: msg_ = YoloObj() msg_.box = bb_arr(box, img.shape) msg_.score = box.get_score() msg_.id = box.get_label() msg_.label = self._labels[msg_.id] msgs_.append(msg_) return YoloResponse(objects=msgs_) def annotate_img(self, img, draw_classes): boxes_ = self._yolo.predict(img, self._score, self._nms) if len(draw_classes): all_boxes_ = boxes_ boxes_ = [] for box in all_boxes_: if self._labels[box.get_label()] in draw_classes: boxes_.append(box) return draw_boxes(img, boxes_, self._config['model']['labels'])
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(feature_extractor=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes_object(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes_object(image, boxes, config['model']['labels']) image_filename = image_path.split('/')[-1] cv2.imwrite('./sample/image_pred_box/' + image_filename, image)
def _detection_thread(): global detected_image, loaded print('Creating model...', end = ' ') yolo = YOLO(architecture='Tiny Yolo', input_size=416, labels=['cube'], max_box_per_image=3, anchors=[0.57273, 0.677385, 1.87446, 2.06253, 3.33843, 5.47434, 7.88282, 3.52778, 9.77052, 9.16828]) yolo.load_weights('save_tiny.h5') print('Done!') loaded = True while True: webcam_lock.acquire() img = webcam_image webcam_lock.release() if img is not None: start = time.time() boxes = yolo.predict(img, nms_threshold=0.5, bgr=False) drawn_img = draw_boxes(img, boxes, ['cube']) end = time.time() fps = 1.0/(end-start) past_fps.append(fps) while len(past_fps) > 10: del past_fps[0] avg_fps = sum(past_fps)/len(past_fps) print('\rFPS: {:.2f}'.format(avg_fps), end='') detected_lock.acquire() detected_image = drawn_img detected_lock.release() if should_stop: break
def test(argparser,test_path): args=argparser.parse_args() config_path=args.conf weights_path=args.weights with open(config_path) as config_buffer: config=json.loads(config_buffer.read()) os.environ["CUDA_VISIBLE_DEVICES"]=config["env"]["gpu"] yolo=YOLO(architecture=config["model"]["architecture"], input_size=config["model"]["input_size"], labels=config["model"]["labels"], max_box_per_img=config["model"]["max_box_per_image"], anchors=config["model"]["anchors"]) yolo.load_weights(weights_path) if test_path[-3:]=="mp4": pass else: video_writer=cv2.VideoWriter(video_out,cv2.VideoWriter_fourcc(*'MPEG'),50.0,(w,h)) start=time.time() for f in os.listdir(test_path): print(f) f_path=os.path.join(test_path,f) # print(f_path) img=cv2.imread(f_path) boxes=yolo.predict(img) img=draw_boxes(boxes,img,config["model"]["labels"]) # cv2.imwrite(out_dir+f_path[-9:],img) video_writer.write(np.uint8(img)) print(time.time()-start) video_writer.release()
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) #model yolo = YOLO(backend = config['model']['backend'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) #Load weights yolo.load_weights(weights_path) # Predict image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes :') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### print(weights_path) yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### pattern = '*.jpg' log_file = 'log_' + datetime.datetime.now().strftime( "%Y_%m_%d_%H_%M_%S") + '.txt' log_str = '' for path, subdirs, files in os.walk(image_path): for name in files: if fnmatch(name, pattern): filename = os.path.join(path, name) print(filename) log_str += path + ',' + name image = cv2.imread(filename) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') for box in boxes: box_label = config['model']['labels'][box.get_label()] box_score = box.get_score() log_str += ',' + box_label + ',' + str(box_score) cv2.imwrite(os.path.join(path, "detected_" + name), image) log_str += '\n' text_file = open(log_file, "w") text_file.write(log_str) text_file.close()
def main(): config_path = "config.json" weights_path = "../large_weights/full_yolo_whale.h5" directory_in_str = "../large_dataset/whale_files/test" df = pd.read_csv("../large_dataset/whale_files/sample_submission.csv", header=None, names=["Image", "Id", "Xmin", "Ymin", "Xmax", "Ymax"]) df = df.drop([0]) manual_check = pd.DataFrame( columns=["Image", "Id", "Xmin", "Ymin", "Xmax", "Ymax"]) with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### directory = os.fsencode(directory_in_str) for file in tqdm(os.listdir(directory)): filename = os.fsdecode(file) if filename.endswith(".jpg"): image = cv2.imread(os.path.join(directory_in_str, filename)) image_h, image_w, _ = image.shape boxes = yolo.predict(image) if len(boxes) == 1: df.at[df.Image == filename, 'Xmin'] = max(floor(boxes[0].xmin * image_w), 0) df.at[df.Image == filename, 'Ymin'] = max(floor(boxes[0].ymin * image_h), 0) df.at[df.Image == filename, 'Xmax'] = min(ceil(boxes[0].xmax * image_w), image_w) df.at[df.Image == filename, 'Ymax'] = min(ceil(boxes[0].ymax * image_h), image_h) else: s = df[df.Image == filename] manual_check = pd.concat([manual_check, s]) else: continue df.to_csv('test_box.csv', encoding='utf-8', index=False) manual_check.to_csv('manual_check_test.csv', encoding='utf-8', index=False)
def _main_(args): ############################### # Prepare data to be detected ############################### # data_folder = "/home/peng/data/good_rolo_data/" data_folder = "/home/peng/data/sort_data/images/" # data_folder = "/home/peng/data/sort_data/images/" video_folders_list = sorted(glob.glob(data_folder + '*')) sort_nicely(video_folders_list) config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture = config['model']['architecture'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load trained weights ############################### print("Weights path:", weights_path) yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### for video_folder in video_folders_list: video_name = basename(video_folder) print("Processing %s." % video_name) image_paths = sorted(glob.glob(os.path.join(video_folder, '*jpg'))) sort_nicely(image_paths) with open('det_mot/' + video_name + '.txt', 'w') as out_file: for i in tqdm(range(len(image_paths))): image = cv2.imread(image_paths[i]) boxes = yolo.predict(image) for box in boxes: x1 = (box.x - box.w/2) * 1280 y1 = (box.y - box.h/2) * 720 w = box.w * 1280 h = box.h * 720 print('%d,-1,%.2f,%.2f,%.2f,%.2f,%.6f,-1,-1,-1' % (i+1, x1, y1, w, h, box.c), file=out_file)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input runID = args.runID with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### outputdir = os.path.join( '/flashblade/lars_data/2018_Cyclomedia_panoramas/project_folder/YOLO/false_positives_dir', runID) if os.path.exists(outputdir): print('path exists') else: os.makedirs(outputdir) print(image_path) imlist = os.listdir(image_path) print(len(imlist)) for file in imlist: if file.endswith('jpg'): print(file) image = cv2.imread(os.path.join(image_path, file)) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') if len(boxes) > 0: filename = file[:-4] + '_detected' + file[-4:] output = os.path.join(outputdir, filename) print(output) cv2.imwrite(output, image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### model_load_time = time.time() yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) print('Model load time is ' + str(time.time() - model_load_time)) ############################### # Predict bounding boxes ############################### inference_time = [] for filename in os.listdir(image_path): img_path = os.path.join(image_path, filename) inference_start_time = time.time() image = cv2.imread(img_path) boxes = yolo.predict(image) inference_time.append(time.time() - inference_start_time) print(len(boxes), 'boxes are found') image = draw_boxes(image, boxes, config['model']['labels']) cv2.imwrite(img_path[:-4] + '_detected' + img_path[-4:], image) print('Avg inference time is ' + str(np.mean(inference_time)) + '+/-' + str(np.std(inference_time)))
def _main_(args): config_path = args.conf weights_path = args.weights input = args.input camera = args.camera with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors'], threshold=config['predict']['threshold'], max_sur=config["predict"]["max_sur"]) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### if camera: ph.predict_with_camera(yolo) elif input[-4:] == '.mp4': ph.predict_with_video(yolo, input, config['predict']['saved']) else: image = cv2.imread(input) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) #print(len(boxes), 'boxes are found') cv2.imwrite(input[:-4] + '_detected' + input[-4:], image)
class DetectorAPI: def __init__(self, weights_path, config_path): import json import os from frontend import YOLO os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"] = "0" with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### self.yolo = YOLO( backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### self.yolo.load_weights(weights_path) self.labels = config['model']['labels'] def processFrame(self, image): import numpy as np import time # Expand dimensions since the trained_model expects images to have shape: [1, None, None, 3] image_np_expanded = np.expand_dims(image, axis=0) # Actual detection. start_time = time.time() boxes = self.yolo.predict(image) end_time = time.time() print("Elapsed Time:", end_time - start_time) return boxes
def _main_(args): config_path = 'config.json' weights_path = 'tiny_yolo_trafficred3.h5' image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### image = cv2.imread(image_path) for item in range(10): start_time = time.time() boxes = yolo.predict(image) duration = time.time() - start_time print('Prediction time %5.2f' % (duration)) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
class Predictor(): def __init__(self, config_path, weights_path): self.config_path = config_path self.weights_path = weights_path with open(config_path) as config_buffer: self.config = json.load(config_buffer) self.yolo = YOLO( backend=self.config['model']['backend'], input_size=self.config['model']['input_size'], labels=self.config['model']['labels'], max_box_per_image=self.config['model']['max_box_per_image'], anchors=self.config['model']['anchors']) self.yolo.load_weights(self.weights_path) def predict(self, image): boxes = self.yolo.predict(image) image = draw_boxes(image, boxes, self.config['model']['labels']) return boxes, image
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.image with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### print weights_path yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print len(boxes), 'boxes are found' cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(): config_path = 'config.json' # weights_path = 'full_yolo_backend.h5' weights_path = 'model.h5' with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### for i in range(80): num = i + 21 file_text = '/home/yuho/Face_Detection/data/photo/frame' image_path = file_text + str(num) + '.png' save_text = '/home/yuho/Face_Detection/data/save_data/frame' save_path = save_text + str(num) + '.png' # image_path = '/home/yuho/Face_Detection/data/photo/frame56.png' # image_path = 'frame19.png' if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) if boxes == 0: pass else: image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(save_path, image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### print(image_path) imlist = os.listdir(image_path) print(imlist) for file in imlist: if file.endswith('jpg'): print(file) image = cv2.imread( os.path.join( '/flashblade/lars_data/2018_Cyclomedia_panoramas/project_folder/YOLO', image_path, file)) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') filename = file[:-4] + '_detected' + file[-4:] output = os.path.join( '/flashblade/lars_data/2018_Cyclomedia_panoramas/project_folder/YOLO', image_path, 'output', filename) print(output) if len(boxes) > 0: cv2.imwrite(output, image) temp_labels = config['model']['labels'] for box in boxes: xmin = int(box.xmin * 1024) ymin = int(box.ymin * 512) xmax = int(box.xmax * 1024) ymax = int(box.ymax * 512) sign_class = temp_labels[box.get_label()] sign_score = box.get_score() print( str(filename.split('_')[1] + '_' + filename.split('_')[2]), xmin, xmax, ymin, ymax, sign_class, sign_score) print( os.path.join( '/flashblade/lars_data/2018_Cyclomedia_panoramas/project_folder/YOLO', image_path, 'output', 'output.txt')) with open( os.path.join( '/flashblade/lars_data/2018_Cyclomedia_panoramas/project_folder/YOLO', image_path, 'output', 'output.txt'), 'a') as f: f.write( "%s,%s,%s,%s,%s,%s,%s\n" % (str( filename.split('_')[1] + '_' + filename.split('_')[2]), xmin, xmax, ymin, ymax, sign_class, sign_score))
def _main_(args): config_path = args.conf weights_path = args.weights with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Parse the annotations ############################### # parse annotations of the validation set, if any, otherwise split the training set if os.path.exists(config['valid']['valid_annot_folder']): valid_imgs, valid_labels = parse_annotation( config['valid']['valid_annot_folder'], config['valid']['valid_image_folder'], config['model']['labels']) else: raise ValueError( 'Validation folder does not exist or is not specified') ############################################ # Make validation generators ############################################ generator_config = { 'IMAGE_H': yolo.input_size, 'IMAGE_W': yolo.input_size, 'GRID_H': yolo.grid_h, 'GRID_W': yolo.grid_w, 'BOX': yolo.nb_box, 'LABELS': yolo.labels, 'CLASS': len(yolo.labels), 'ANCHORS': yolo.anchors, 'BATCH_SIZE': config['train']['batch_size'], 'TRUE_BOX_BUFFER': yolo.max_box_per_image, } generator = BatchGenerator(valid_imgs, generator_config, norm=yolo.feature_extractor.normalize, jitter=False) y_true = [] y_predicted = [] for i in range(generator.size()): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = yolo.predict(raw_image) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[ box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score ] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # store predicted label for the image i. # since multiple boxes may be predicted, choose the one with the highest score # TODO: find out why there are no predictions at all for certain images if pred_labels.any(): y_predicted.append(pred_labels[0]) else: y_predicted.append(4) # load true image annotations annotations = generator.load_annotation(i) if annotations.shape[0] > 1: raise ValueError('Multiple objects exist per image not supported') ### store the true label for the image i y_true.append(annotations[0, 4]) print('Processed ' + str(len(y_true)) + 'imgaes') print('Confusion Matrix') print(confusion_matrix(y_true, y_predicted)) print('Classification Report') # added NoPrediction label to number of classes as yolo model returned null prediction for some images target_names = config['model']['labels'] + ['NoPrediction'] print(classification_report(y_true, y_predicted, target_names=target_names))
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### print(weights_path) yolo.load_weights(weights_path) ############################### # Predict bounding boxes #######d######################## if image_path[-4:] == '.mp4' or image_path[-4:] == '.mov': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() elif image_path == 'webcam': video_reader = cv2.VideoCapture(0) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) while True: _, image = video_reader.read() boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) cv2.imshow('cube_detector', image) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input keras.backend.tensorflow_backend.set_session(get_session()) with open(config_path) as config_buffer: config = json.load(config_buffer) if weights_path == '': weights_path = config['train']['pretrained_weights"'] ############################### # Make the model ############################### input_size = (config['model']['input_size_h'], config['model']['input_size_w']) yolo = YOLO(backend=config['model']['backend'], input_size=(config['model']['input_size_h'], config['model']['input_size_w']), labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors'], gray_mode=config['model']['gray_mode']) if config['model']['gray_mode']: depth = 1 else: depth = 3 yolo.load_weights(weights_path) if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] #cap = FileVideoStream(image_path).start() cap = cv2.VideoCapture(image_path) time.sleep(1.0) # fps = FPS().start() fps_img = 0.0 counter = 0 while True: start = time.time() ret, image = cap.read() if depth == 1: # convert video to gray image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) image = cv2.resize(image, input_size, interpolation=cv2.INTER_CUBIC) image = np.expand_dims(image, 2) #image = np.array(image, dtype='f') else: if counter == 1: print("Color image") image = cv2.resize(image, input_size, interpolation=cv2.INTER_CUBIC) #image = np.array(image, dtype='f') #image = np.divide(image, 255.) tm_inf = time.time() boxes = yolo.predict(image) fps_img = (fps_img + (1 / (time.time() - start))) / 2 print("Inference time: {:.4f}".format(time.time() - tm_inf)) image = draw_boxes(image, boxes, config['model']['labels']) image = cv2.putText(image, "fps: {:.2f}".format(fps_img), (0, 20), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 1, 4) cv2.imshow("Press q to quit", image) # fps.update() #if counter == 10: #print(image.sum(), boxes) # time.sleep(1) counter += 1 if cv2.getWindowProperty("Press q to quit", cv2.WND_PROP_ASPECT_RATIO) < 0.0: print("Window closed") break elif cv2.waitKey(1) & 0xFF == ord('q'): print("Q pressed") break # fps.stop() # print("[INFO] elasped time: {:.2f}".format(fps.elapsed())) # print("[INFO] approx. FPS: {:.2f}".format(fps.fps())) cap.release() else: images = list(list_images(image_path)) for fname in images[100:]: image = cv2.imread(fname) tm_inf = time.time() boxes = yolo.predict(image) print("Inference time: {:.4f}".format(time.time() - tm_inf)) image = draw_boxes(image, boxes, config['model']['labels']) cv2.imshow("Press q to quit", image) if cv2.waitKey(1) & 0xFF == ord('q'): break time.sleep(2) cv2.destroyAllWindows()
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend=config['model']['backend'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 50.0, (frame_w, frame_h)) for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) image_h, image_w, _ = image.shape box_arr = [] for box in boxes: xmin = int(box.xmin * image_w) ymin = int(box.ymin * image_h) xmax = int(box.xmax * image_w) ymax = int(box.ymax * image_h) box_arr.append([xmin, xmax, ymin, ymax]) with open('box_arr.pkl', 'wb') as f: pickle.dump(box_arr, f) # image = draw_boxes(image, boxes, config['model']['labels']) # video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image_h, image_w, _ = image.shape box_arr = [] for box in boxes: xmin = int(box.xmin * image_w) ymin = int(box.ymin * image_h) xmax = int(box.xmax * image_w) ymax = int(box.ymax * image_h) box_arr.append([xmin, xmax, ymin, ymax]) with open('box_arr.pkl', 'wb') as f: pickle.dump(box_arr, f) # image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found')
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### print(weights_path) yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### # if it's an image, do detection, save image with bounding boxes to the same folder # if it's a folder, do detection, save images with boundins boxes to another folder # if result folder is present, save annotations to the result folder if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = imageio.get_reader(image_path, 'ffmpeg') nb_frames = video_reader._meta['nframes'] frame_h = 480 frame_w = 640 video_writer = imageio.get_writer(video_out, fps=20) for i in tqdm(range(0, nb_frames, 3)): image = video_reader.get_data(i) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) video_writer.append_data(np.uint8(image)) video_writer.close() else: image = cv2.imread(image_path) boxes = yolo.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) yolo2 = YOLO(architecture=config['model']['architecture'], input_size=config['model']['input_size'], labels=config['model']['labels'], max_box_per_image=config['model']['max_box_per_image'], anchors=config['model']['anchors']) ############################### # Load trained weights ############################### print(weights_path) yolo.load_weights( weights_path) #feed in the main one, charm on can load on its own #yolo2.load_weights('charm_detector_3_12.h5') ############################### # Predict bounding boxes ############################### print('reading input') if image_path[-4:] == '.mp4': video_out = image_path[:-4] + '_detected' + image_path[-4:] video_reader = cv2.VideoCapture(image_path) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) video_writer = cv2.VideoWriter(video_out, cv2.VideoWriter_fourcc(*'MPEG'), 30.0, (frame_w, frame_h)) charm_count = 0 charm_wait = 0 orb_count = 0 orb_wait = 0 for i in tqdm(range(nb_frames)): #can just make function that checks labels. # and respits out the boxes? frames are at 60fps xD # i+240 can be how long it delays those things for _, image = video_reader.read() boxes = yolo.predict(image) #boxes2 = yolo2.predict(image) #dont really have to draw the orb boxes... but can tally at the side or something image = draw_boxes(image, boxes, config['model']['labels']) #def skillshot_count(skillshot_name,skillshot_count,boxes,labels,frame_i,wait_i): charm_count, charm_wait = skillshot_count( 'charm', charm_count, boxes, config['model']['labels'], i, charm_wait) orb_count, orb_wait = skillshot_count('orb', orb_count, boxes, config['model']['labels'], i, orb_wait) label = 'Count of Orb of Deceptions: ' + str(orb_count) cv2.putText(image, label, (0, 475), 3, cv2.FONT_HERSHEY_PLAIN, (0, 255, 0), 2) label = 'Count of Charms: ' + str(charm_count) cv2.putText(image, label, (0, 525), 3, cv2.FONT_HERSHEY_PLAIN, (0, 255, 0), 2) video_writer.write(np.uint8(image)) video_reader.release() video_writer.release() else: image = cv2.imread(image_path) boxes = yolo.predict(image) boxes2 = yolo2.predict(image) image = draw_boxes(image, boxes, config['model']['labels']) image = charm_draw_boxes(image, boxes2, config['model']['labels']) print(len(boxes), 'boxes are found') cv2.imwrite(image_path[:-4] + '_detected' + image_path[-4:], image)
def online_tracking(data_dir, STORE=False): if not os.path.exists(data_dir): raise IOError("Invalid data path:", data_dir) yolo_config_path = "../config_aerial.json" with open(yolo_config_path) as config_buffer: yolo_config = json.load(config_buffer) yolo = YOLO(architecture=yolo_config['model']['architecture'], input_size=yolo_config['model']['input_size'], labels=yolo_config['model']['labels'], max_box_per_image=yolo_config['model']['max_box_per_image'], anchors=yolo_config['model']['anchors']) yolo_weights_path = "../yolo_coco_aerial_person.h5" print("YOLO weights path:", yolo_weights_path) yolo.load_weights(yolo_weights_path) colours = np.round(np.random.rand(32, 3) * 255) frame_width = 1280 frame_height = 720 if STORE: video_name = data_dir.split('/')[-2] FPS = 30 # remember to modify frame width and height before testing video video_writer = cv2.VideoWriter( 'output_video/' + video_name + '.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), FPS, (frame_width, frame_height)) image_paths = sorted(glob.glob(os.path.join(data_dir, '*jpg'))) sort_nicely(image_paths) mot_tracker = Sort() # create instance of the SORT tracker total_time = 0.0 for i, image_path in enumerate(tqdm(image_paths)): image = cv2.imread(image_path) track_start_time = time.time() boxes = yolo.predict(image) detect_time = time.time() - track_start_time sort_start_time = time.time() dets = boxes2dets(boxes, image.shape) trackers = mot_tracker.update(dets) end_time = time.time() cycle_time = end_time - track_start_time total_time += cycle_time sort_time = end_time - sort_start_time for d in trackers: color = colours[int(d[4]) % 32] cv2.rectangle(image, (int(d[0]), int(d[1])), (int(d[2]), int(d[3])), color, 3) cv2.putText(image, 'id = ' + str(int(d[4])), (int(d[0]), int(d[1]) - 13), cv2.FONT_HERSHEY_SIMPLEX, 1e-3 * image.shape[0], color, 2) cv2.putText(image, 'Tracking FPS = {:.2f}'.format(1 / cycle_time), (frame_width - 300, 25), cv2.FONT_HERSHEY_SIMPLEX, 1e-3 * image.shape[0], (0, 250, 0), 2) cv2.putText(image, ' YOLO FPS = {:.2f}'.format(1 / detect_time), (frame_width - 300, 55), cv2.FONT_HERSHEY_SIMPLEX, 1e-3 * image.shape[0], (0, 250, 0), 2) cv2.putText(image, ' SORT FPS = {:.2f}'.format(1 / sort_time), (frame_width - 300, 75), cv2.FONT_HERSHEY_SIMPLEX, 1e-3 * image.shape[0], (0, 250, 0), 2) if STORE: video_writer.write(image) else: cv2.imshow("output", image) cv2.waitKey(0) if i > 450: break total_frames = i + 1 print("Total Tracking took: %.3f for %d frames or %.1f FPS" % (total_time, total_frames, total_frames / total_time))
def _main_(args): config_path = args.conf weights_path = args.weights image_path = args.input with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(backend = config['model']['backend'], input_shape = config['model']['input_shape'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load trained weights ############################### yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### fig,ax=plt.subplots(1) # bbox x # globe eta # bbox y # globe phi # bbox width # Gaussian sigma (required to be 3*sigma<pi) # bbox height # Gaussian sigma (required to be 3*sigma<pi) file_content = np.load(image_path) images = file_content['raw'] truth_boxes = file_content['truth'] for image_index in range(10): image = images[image_index] all_objs = truth_boxes[image_index] print(image.shape) boxes = yolo.predict(image) print(len(boxes), 'boxes are found') for i in range(len(boxes)): b = boxes[i] print('box:',i,b) draw_boxes(image, ax, boxes, config['model']['labels'],color='y',scale=True) obj_boxes=[] i=0 for obj in all_objs: # x,y,w,h = obj[:4] y,x,h,w = obj[1:5] b = BoundBox(x-w/2,y-h/2,x+w/2,y+h/2) # print('box:',i,b,obj[5],obj[6],obj[7],obj[8],obj[9]) print('box:',i,obj) obj_boxes.append( b ) i+=1 draw_boxes(image, ax, obj_boxes, config['model']['labels'],color='g',scale=False) #image = draw_boxes(image, boxes, config['model']['labels']) i=np.swapaxes(np.swapaxes(image,0,1),1,2) x=np.sum(i,axis=2) #plt.imshow(x,cmap='hot') plt.imshow(x,aspect='auto',extent=(0,256,0,9600),interpolation='nearest',cmap=cm.jet) plt.savefig('out%d.png' % image_index ,dpi=200)
def predict(config_path, weights_path, filenames, path_in, path_out): with open(config_path) as config_buffer: config = json.load(config_buffer) ############################### # Make the model ############################### yolo = YOLO(architecture = config['model']['architecture'], input_size = config['model']['input_size'], labels = config['model']['labels'], max_box_per_image = config['model']['max_box_per_image'], anchors = config['model']['anchors']) ############################### # Load trained weights ############################### print(weights_path) yolo.load_weights(weights_path) ############################### # Predict bounding boxes ############################### for filename in filenames: fp_in = os.path.join(path_in, filename) fp_out = os.path.join(path_out, filename) if fp_in[-4:] == '.mp4': video_reader = cv2.VideoCapture(fp_in) nb_frames = int(video_reader.get(cv2.CAP_PROP_FRAME_COUNT)) frame_h = int(video_reader.get(cv2.CAP_PROP_FRAME_HEIGHT)) frame_w = int(video_reader.get(cv2.CAP_PROP_FRAME_WIDTH)) fps = int(video_reader.get(cv2.CAP_PROP_FPS)) video_writer = cv2.VideoWriter(fp_out, cv2.VideoWriter_fourcc(*'mp4v'), fps, (frame_w, frame_h)) boxes_count = 0 for i in tqdm(range(nb_frames)): _, image = video_reader.read() boxes = yolo.predict(image) boxes_count += len(boxes) # image = draw_boxes(image, boxes, config['model']['labels']) image = draw_boxes(image, boxes, config['model']['labels'], 'pixelate', .025, .5) video_writer.write(np.uint8(image)) acc = boxes_count/nb_frames print('%s average accuracy (boxes found per frame)' % acc ) if (acc < .3): os.remove(fp_out) video_reader.release() video_writer.release() else: image = cv2.imread(fp_in) boxes = yolo.predict(image) if len(boxes) > 0 or '_thumb' in filename: print('%s: %d boxes found ' % (filename, len(boxes)) ) # good settings for cv2.INTER_CUBIC # img = draw_boxes(img, boxes, config['model']['labels'], 'pixelate', .04, .5) # good settings for cv2.INTER_LINEAR image = draw_boxes(image, boxes, config['model']['labels'], 'pixelate', .025, .5) # Save cv2.imwrite(fp_out, image)