img_path.rstrip('\n')
] + single_prediction + [x_size, y_size]],
columns=[
'image', 'image_path', 'xmin', 'ymin',
'xmax', 'ymax', 'label', 'confidence',
'x_size', 'y_size'
]))
end = timer()
print('Processed {} images in {:.1f}sec - {:.1f}FPS'.format(
len(input_image_paths), end - start,
len(input_image_paths) / (end - start)))
out_df.to_csv(FLAGS.box, index=False)
# This is for videos
if input_video_paths:
print('Found {} input videos: {} ...'.format(
len(input_video_paths),
[os.path.basename(f) for f in input_video_paths[:5]]))
start = timer()
for i, vid_path in enumerate(input_video_paths):
output_path = os.path.join(
FLAGS.output,
os.path.basename(vid_path).replace('.', FLAGS.postfix + '.'))
detect_video(yolo, vid_path, output_path=output_path)
end = timer()
print('Processed {} videos in {:.1f}sec'.format(
len(input_video_paths), end - start))
# Close the current yolo session
yolo.close_session()
# This is for videos
# for pre-recorded videos present in the Test_Images folder
if input_video_paths and not webcam_active:
print("Found {} input videos: {} ...".format(
len(input_video_paths),
[os.path.basename(f) for f in input_video_paths[:5]],
))
out_df = pd.DataFrame(
columns=["xmin", "ymin", "xmax", "ymax", "label", "confidence"])
start = timer()
for i, vid_path in enumerate(input_video_paths):
output_path = os.path.join(
FLAGS.output,
os.path.basename(vid_path).replace(".", FLAGS.postfix + "."),
)
prediction = detect_video(yolo, vid_path, output_path=output_path)
for single_prediction in prediction:
out_df = out_df.append(
pd.DataFrame(
[single_prediction],
columns=[
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
],
))
end = timer()
print("Processed {} videos in {:.1f}sec".format(
'''
parser.add_argument("--input",
nargs='?',
type=str,
required=False,
default='./path2your_video',
help="Video input path")
parser.add_argument("--output",
nargs='?',
type=str,
default="",
help="[Optional] Video output path")
FLAGS = parser.parse_args()
if FLAGS.image:
"""
Image detection mode, disregard any remaining command line arguments
"""
print("Image detection mode")
if "input" in FLAGS:
print(" Ignoring remaining command line arguments: " +
FLAGS.input + "," + FLAGS.output)
detect_img(YOLO(**vars(FLAGS)))
elif "input" in FLAGS:
detect_video(YOLO(**vars(FLAGS)), FLAGS.input, FLAGS.output)
else:
print(
"Must specify at least video_input_path. See usage with --help.")
# This is for videos
# for pre-recorded videos present in the Test_Images folder
if input_video_paths and not webcam_active:
print(
"Found {} input videos: {} ...".format(
len(input_video_paths),
[os.path.basename(f) for f in input_video_paths[:5]],
)
)
start = timer()
for i, vid_path in enumerate(input_video_paths):
output_path = os.path.join(
FLAGS.output,
os.path.basename(vid_path).replace(".", FLAGS.postfix + "."),
)
detect_video(yolo, vid_path, output_path=output_path, calibr_param=calibr_param)
end = timer()
print(
"Processed {} videos in {:.1f}sec".format(
len(input_video_paths), end - start
)
)
# for Webcam
if webcam_active:
start = timer()
detect_webcam(yolo)
end = timer()
print("Processed from webcam for {:.1f}sec".format(end - start))
# Close the current yolo session
def detect(image_test_folder):
# Delete all default flags
parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
"""
Command line options
"""
parser.add_argument(
"--input_path",
type=str,
default=image_test_folder,
help=
"Path to image/video directory. All subdirectories will be included. Default is "
+ image_test_folder,
)
parser.add_argument(
"--output",
type=str,
default=fp.detection_results_folder,
help="Output path for detection results. Default is " +
fp.detection_results_folder,
)
parser.add_argument(
"--no_save_img",
default=False,
action="store_true",
help=
"Only save bounding box coordinates but do not save output images with annotated boxes. Default is False.",
)
parser.add_argument(
"--file_types",
"--names-list",
nargs="*",
default=[],
help=
"Specify list of file types to include. Default is --file_types .jpg .jpeg .png .mp4",
)
parser.add_argument(
"--yolo_model",
type=str,
dest="model_path",
default=fp.YOLO_weights,
help="Path to pre-trained weight files. Default is " + fp.YOLO_weights,
)
parser.add_argument(
"--anchors",
type=str,
dest="anchors_path",
default=fp.anchors_path,
help="Path to YOLO anchors. Default is " + fp.anchors_path,
)
parser.add_argument(
"--classes",
type=str,
dest="classes_path",
default=fp.YOLO_classname,
help="Path to YOLO class specifications. Default is " +
fp.YOLO_classname,
)
parser.add_argument("--gpu_num",
type=int,
default=1,
help="Number of GPU to use. Default is 1")
parser.add_argument(
"--confidence",
type=float,
dest="score",
default=0.25,
help=
"Threshold for YOLO object confidence score to show predictions. Default is 0.25.",
)
parser.add_argument(
"--box_file",
type=str,
dest="box",
default=fp.detection_results_file,
help="File to save bounding box results to. Default is " +
fp.detection_results_file,
)
parser.add_argument(
"--postfix",
type=str,
dest="postfix",
default="_fish",
help=
'Specify the postfix for images with bounding boxes. Default is "_fish"',
)
FLAGS = parser.parse_args()
save_img = not FLAGS.no_save_img
file_types = FLAGS.file_types
if file_types:
input_paths = GetFileList(FLAGS.input_path, endings=file_types)
else:
input_paths = GetFileList(FLAGS.input_path)
# Split images and videos
img_endings = (".jpg", ".jpg", ".png")
vid_endings = (".mp4", ".mpeg", ".mpg", ".avi")
input_image_paths = []
input_video_paths = []
for item in input_paths:
if item.endswith(img_endings):
input_image_paths.append(item)
elif item.endswith(vid_endings):
input_video_paths.append(item)
output_path = FLAGS.output
if not os.path.exists(output_path):
os.makedirs(output_path)
# define YOLO detector
yolo = YOLO(
**{
"model_path": FLAGS.model_path,
"anchors_path": FLAGS.anchors_path,
"classes_path": FLAGS.classes_path,
"score": FLAGS.score,
"gpu_num": FLAGS.gpu_num,
"model_image_size": (416, 416),
})
# Make a dataframe for the prediction outputs
out_df = pd.DataFrame(columns=[
"image",
"image_path",
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
"x_size",
"y_size",
])
# labels to draw on images
class_file = open(FLAGS.classes_path, "r")
input_labels = [line.rstrip("\n") for line in class_file.readlines()]
print("Found {} input labels: {} ...".format(len(input_labels),
input_labels))
if input_image_paths:
print("Found {} input images: {} ...".format(
len(input_image_paths),
[os.path.basename(f) for f in input_image_paths[:5]],
))
start = timer()
text_out = ""
# This is for images
for i, img_path in enumerate(input_image_paths):
print(img_path)
prediction, image = detect_object(
yolo,
img_path,
save_img=save_img,
save_img_path=FLAGS.output,
postfix=FLAGS.postfix,
)
y_size, x_size, _ = np.array(image).shape
for single_prediction in prediction:
out_df = out_df.append(
pd.DataFrame(
[[
os.path.basename(img_path.rstrip("\n")),
img_path.rstrip("\n"),
] + single_prediction + [x_size, y_size]],
columns=[
"image",
"image_path",
"xmin",
"ymin",
"xmax",
"ymax",
"label",
"confidence",
"x_size",
"y_size",
],
))
end = timer()
print("Processed {} images in {:.1f}sec - {:.1f}FPS".format(
len(input_image_paths),
end - start,
len(input_image_paths) / (end - start),
))
out_df.to_csv(FLAGS.box, index=False)
# This is for videos
if input_video_paths:
print("Found {} input videos: {} ...".format(
len(input_video_paths),
[os.path.basename(f) for f in input_video_paths[:5]],
))
start = timer()
for i, vid_path in enumerate(input_video_paths):
output_path = os.path.join(
FLAGS.output,
os.path.basename(vid_path).replace(".", FLAGS.postfix + "."),
)
detect_video(yolo, vid_path, output_path=output_path)
end = timer()
print("Processed {} videos in {:.1f}sec".format(
len(input_video_paths), end - start))
# Close the current yolo session
yolo.close_session()
return fp.detection_results_folder
print("Processed {} images in {:.1f}sec - {:.1f}FPS".format(
len(input_image_paths),
end - start,
len(input_image_paths) / (end - start),
))
out_df.to_csv(FLAGS.box, index=False)
# This is for videos
"""if input_video_paths:
print(
"Found {} input videos: {} ...".format(
len(input_video_paths),
[os.path.basename(f) for f in input_video_paths[:5]],
)
)
for i, vid_path in enumerate(input_video_paths):
output_path = os.path.join(
FLAGS.output,
os.path.basename(vid_path).replace(".", FLAGS.postfix + "."),
)"""
start = timer()
detect_video(yolo)
end = timer()
print("Processed {} videos in {:.1f}sec".format(len(input_video_paths),
end - start))
# Close the current yolo session
yolo.close_session()
