def get_segmentation_model(model_type, freeze=True):
x = None
segmentation_model = None
if model_type == "three_class_trained":
segmentation_model = model_from_checkpoint_path(
three_class_checkpoints_path)
elif model_type == "seven_class_trained":
segmentation_model = model_from_checkpoint_path(
seven_class_checkpoints_path)
x = segmentation_model.get_layer("conv2d_6").output
elif model_type == "pretrained":
segmentation_model = pspnet_101_cityscapes()
x = segmentation_model.get_layer("activation_107").output
elif model_type == "seven_class_vanilla_psp":
segmentation_model = model_from_checkpoint_path(
seven_class_vanilla_psp_path)
x = segmentation_model.get_layer("activation_10").output
elif model_type == "seven_class_vanilla_psp_depth":
from utils.pspnet import model_from_checkpoint_path as custom_model_from_checkpoint_path
segmentation_model = custom_model_from_checkpoint_path(
seven_class_vanilla_psp_depth_path)
x = segmentation_model.get_layer("activation_10").output
elif model_type == "seven_class_mobile":
segmentation_model = model_from_checkpoint_path(
seven_class_mobile_checkpoints_path)
output_layer = get_layer_with_name(segmentation_model,
"conv_dw_6_relu")
x = output_layer.output
elif model_type == "resnet50_pspnet_8_classes":
segmentation_model = model_from_checkpoint_path(
resnet50_pspnet_8_classes)
output_layer = segmentation_model.get_layer(name="conv2d_6")
x = output_layer.output
plot_model(segmentation_model, "segmentation_model.png", show_shapes=True)
# Explicitly define new model input and output by slicing out old model layers
model_new = Model(inputs=segmentation_model.layers[0].input, outputs=x)
if freeze:
for layer in model_new.layers:
layer.trainable = False
return model_new
def evaluate(model=None,
inp_images=None,
annotations=None,
checkpoints_path=None,
epoch=None):
#Finished implementation of the evaluate function in keras_segmentation.predict
#Input: array of paths or nd arrays
if model is None and (not checkpoints_path is None):
model = model_from_checkpoint_path(checkpoints_path, epoch)
ious = []
pred_time = []
for inp, ann in zip(inp_images, annotations):
t_start = time.time()
pr = predict_fast(model, inp)
t_end = time.time()
pred_time.append(t_end - t_start)
print('Prediction time: ', t_end - t_start)
gt = get_segmentation_arr(ann,
model.n_classes,
model.output_width,
model.output_height,
no_reshape=True)
gt = gt.argmax(-1)
iou = metrics.get_iou(gt, pr, model.n_classes)
ious.append(iou)
print("Class wise IoU ", np.mean(ious, axis=0))
print("Total IoU ", np.mean(ious))
print("Median prediction time:", np.median(pred_time))
def evaluate(model=None,
inp_images=None,
annotations=None,
checkpoints_path=None,
epoch=None,
visualize=False,
output_folder=''):
#Finished implementation of the evaluate function in keras_segmentation.predict
#Input: array of paths or nd arrays
if model is None and (not checkpoints_path is None):
model = model_from_checkpoint_path(checkpoints_path, epoch)
ious = []
pred_time = []
for inp, ann in tqdm(zip(inp_images, annotations)):
t_start = time.time()
pr = predict_fast(model, inp)
t_end = time.time()
pred_time.append(t_end - t_start)
#print('Prediction time: ', pred_time)
gt = get_segmentation_arr(ann,
model.n_classes,
model.output_width,
model.output_height,
no_reshape=True)
gt = gt.argmax(-1)
iou = metrics.get_iou(gt, pr, model.n_classes)
ious.append(iou)
if visualize:
fig = vis_pred_vs_gt_separate(inp, pr, gt)
plt.title("Predicted mask and errors. "
"IOU (bg, crop, lane):" + str(iou))
if not output_folder:
if epoch is None:
epoch = ''
print(checkpoints_path, epoch, os.path.basename(inp))
fig.savefig(checkpoints_path + epoch + '_IOU_' +
os.path.basename(inp))
print(
'Saving to: ',
checkpoints_path + epoch + '_IOU_' + os.path.basename(inp))
else:
fig.savefig(
os.path.join(
output_folder,
os.path.basename(checkpoints_path) + '_IOU_' +
os.path.basename(inp)))
print ious
ious = np.array(ious)
print("Class wise IoU ", np.mean(ious, axis=0))
print("Total IoU ", np.mean(ious))
print("Mean prediction time:", np.mean(pred_time))
def segment_images_psp(path_to_checkpoint, folder_name):
output_folder_name = folder_name + "_segm"
checkpoint = model_from_checkpoint_path(path_to_checkpoint)
#checkpoint = pspnet_101_cityscapes()
output_folder = data_folder / output_folder_name
verify_folder_exists(output_folder)
for filename in os.listdir(str(data_folder / folder_name)):
out_name = str(output_folder / filename).replace("jpg", "png")
in_name = str(data_folder / folder_name / filename)
checkpoint.predict_segmentation(out_fname=out_name, inp=in_name)
def predict(images, predictions, pretrained, entire_image, checkpoint_dir):
if pretrained:
model = pspnet_101_cityscapes(
) # load the pretrained model trained on Cityscapes dataset
else:
model = model_from_checkpoint_path(normpath(checkpoint_dir))
files = [f for f in listdir(images) if isfile(join(images, f))]
for file in files:
name, ext = splitext(file)
if entire_image:
predict_standard(model,
inp=f'{images}{file}',
out_fname=f'{predictions}{name}.png')
else:
predict_split(model,
inp=f'{images}{file}',
out_fname=f'{predictions}{name}.png')
def main():
# Setup the testing parameters, input paths etc.,
checkpoints_path = "./checkpoints_mobilenet_unet_2class/"
test_images_path = "./dataset2/images_prepped_test/"
test_annotations_path = "./dataset2/annotations_prepped_test_2class/"
# Model checkpoint path should exist, else it is an error.
if not os.path.exists(checkpoints_path):
print("[ERROR] invalid checkpoints path {}".format(checkpoints_path))
sys.exit(1)
# Load model from checkpoint path.
model = model_from_checkpoint_path(checkpoints_path)
# Get Intersection over Union (IoU) results for the test data set.
# The model is picked up from the latest model in the checkpoints_path.
# The input images and masks (annotations) are picked up from their paths.
test_results = evaluate(inp_images_dir=test_images_path,
annotations_dir=test_annotations_path,
model=model)
print(test_results)
print("Evaluation complete")
def __init__(self):
#### Hyperparameters ####
self.image = Image()
self.output_image = Image()
self.bridge = CvBridge()
# ROS setup paramters
self.image_topic_name = rosparam.get_param('camera_topic')
self.model_config = rosparam.get_param('model_config')
self.model_weights = rosparam.get_param('model_weights')
self.model_prefix = rosparam.get_param('model_prefix')
self.visualize = rosparam.get_param('visualize')
self.output_video = True
self.output_video_file_s = rosparam.get_param('output_video_file_s')
self.output_video_file_l = rosparam.get_param('output_video_file_l')
self.lane_fit = True
self.evaluate = False
self.output_file = None
self.display = False
self.seg_arr = []
self.fit = []
self.class_number = 2
#self.loaded_weights = False
self.img_receive = False
self.epoch = None
#model = predict.model_from_checkpoint_files( model_prefix, epoch)#model_config, model_weights)
self.model = predict.model_from_checkpoint_path(
self.model_prefix, self.epoch)
#Listen to image messages and publish predictions with callback
self.img_sub = rospy.Subscriber(self.image_topic_name, Image,
self.imageCallback)
#Set up publisher for prediction messages
self.fit_pub = rospy.Publisher('centerline_local', PoseArray)
self.rate = rospy.Rate(1) # 10hz
# Saving outputs as Video file
self.fourcc = cv2.VideoWriter_fourcc(
*"MJPG") # ('I','Y','U','V') #tried('M','J','P','G')
self.wr = None
(self.out_h, self.out_w) = (None, None)
self.isColor = True
self.fps = 6
self.fourcc_1 = cv2.VideoWriter_fourcc(
*"MJPG") #('I','Y','U','V') #tried('M','J','P','G')
self.wr_1 = None
(self.out_h_1, self.out_w_1) = (None, None)
self.isColor_1 = True
self.fps_1 = 6
## GNSS ground truth
self.book = pe.get_book(
file_name=expanduser("~") +
"/planner_ws/src/vision-based-navigation-agri-fields/auto_nav/config/ground_truth_coordinates.xls"
)
self.gt_lat_utm = []
self.gt_long_utm = []
self.lane_number = str(2)
self.listener = tf.TransformListener()
self.listener.waitForTransform("utm", "base_link", rospy.Time(),
rospy.Duration(4.0))
for row in self.book["Sheet" + self.lane_number]:
self.gt_lat_utm.append(row[1]) # Latitude
self.gt_long_utm.append(row[2]) # Longitude
self.dist_0 = 0
def __init__(self):
#### Hyperparameters ####
self.image = Image()
self.output_image = Image()
self.bridge = CvBridge()
# ROS setup paramters
self.image_topic_name = rosparam.get_param(
'auto_nav/segnet_lane_detection/camera_topic')
self.model_config = rosparam.get_param(
'auto_nav/segnet_lane_detection/model_config')
self.model_weights = rosparam.get_param(
'auto_nav/segnet_lane_detection/model_weights')
self.model_prefix = rosparam.get_param(
'auto_nav/segnet_lane_detection/model_prefix')
self.visualize = rosparam.get_param(
'auto_nav/segnet_lane_detection/visualize')
self.output_video = True
self.output_video_file_s = rosparam.get_param(
'auto_nav/segnet_lane_detection/output_video_file_s')
self.output_video_file_l = rosparam.get_param(
'auto_nav/segnet_lane_detection/output_video_file_l')
self.lane_fit = True
self.evaluate = False
self.output_file = None
self.display = False
self.seg_arr = []
self.fit = []
self.class_number = 2
#self.loaded_weights = False
self.img_receive = False
self.epoch = None
#model = predict.model_from_checkpoint_files( model_prefix, epoch)#model_config, model_weights)
self.model = predict.model_from_checkpoint_path(
self.model_prefix, self.epoch) #, self.loaded_weights
#Listen to image messages and publish predictions with callback
self.img_sub = rospy.Subscriber(self.image_topic_name, Image,
self.imageCallback)
#Set up publisher for prediction messages
self.fit_pub = rospy.Publisher('centerline_local', PoseArray)
self.rate = rospy.Rate(1) # 10hz
# Saving outputs as Video file
self.fourcc = cv2.VideoWriter_fourcc(
*"MJPG") # ('I','Y','U','V') #tried('M','J','P','G')
self.wr = None
(self.out_h, self.out_w) = (None, None)
self.isColor = True
self.fps = 6
self.fourcc_1 = cv2.VideoWriter_fourcc(
*"MJPG") #('I','Y','U','V') #tried('M','J','P','G')
self.wr_1 = None
(self.out_h_1, self.out_w_1) = (None, None)
self.isColor_1 = True
self.fps_1 = 6
if __name__ == '__main__':
try:
# Initialize node
rospy.init_node('online_da_predict')
nav_obj = hilly_nav()
model_prefix = rospy.get_param("/model_prefix")
epoch = rospy.get_param("/epoch")
input_folder = rospy.get_param("/input_folder")
output_folder = rospy.get_param("/output_folder")
#Load model
model = predict.model_from_checkpoint_path(model_prefix, epoch)
while not rospy.is_shutdown():
# print('Output_folder',output_folder)
# im_files = glob.glob(os.path.join(input_folder,'*.jpg'))
# print(os.path.join(input_folder+'*.png'))
# for im in sorted(im_files):
# if output_folder:
# base = os.path.basename(im)
# output_file = os.path.join(output_folder,os.path.splitext(base)[0])+"_pred.png"
# print(output_file)
# else:
# output_file = None
if nav_obj.img_received == True:
seg_arr = nav_obj.predict_on_image(model,
plot_3d = "N"
frame_interval_for_3d = 1
plot_main_lines = "N"
plot_center = "N"
plot_apex = "N"
plot_all_lines = "N"
plot_intersection = "N"
plot_contour = "N"
plot_ellipse = "N"
show_original = "N"
show_segmentation = "N"
show_contour = "N"
show_output = "N"
# First we select the model to use, best results were obtained with mobilnet, so run the program with "-m 0"
model = model_from_checkpoint_path("Checkpoints\\mobilenet_alltools")
angleFilter = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0
]
SetBoxWidget()
tform = vtk.vtkTransform()
base_path = os.path.join("C:\\Users\\Leonardo\\Desktop\\DatasetToTag",
folder)
create_excel(folder)
# while in modo che passi all'immagine successiva solo quando settano il modello 3d
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Feb 23 18:08:34 2020
@author: craig
"""
from keras_segmentation.models.unet import vgg_unet
from keras_segmentation.predict import model_from_checkpoint_path
model = vgg_unet(n_classes=51, input_height=416, input_width=608)
model = model_from_checkpoint_path("weights/vgg_unet_1")
model.train(
train_images="dataset1/images_prepped_train/",
train_annotations="dataset1/annotations_prepped_train/",
val_images="dataset1/images_prepped_test/",
val_annotations="dataset1/annotations_prepped_test/",
verify_dataset=True,
# load_weights="weights/vgg_unet_1.4" ,
optimizer_name='adadelta',
do_augment=True,
augmentation_name="aug_all",
checkpoints_path="weights/vgg_unet_1",
epochs=10)
# Display the model's architecture
model.summary()
frame_interval_for_3d = 1
plot_main_lines = "Y"
plot_center = "N"
plot_apex = "N"
plot_all_lines = "N"
plot_intersection = "N"
plot_contour = "N"
plot_ellipse = "N"
show_original = "N"
show_segmentation = "N"
show_contour = "N"
show_output = "Y"
# First we select the model to use, best results were obtained with mobilnet, so run the program with "-m 0"
if run_model == 0:
model = model_from_checkpoint_path("Checkpoints\\mobilenet_alltools")
elif run_model == 1:
model = model_from_checkpoint_path("..\\Checkpoints\\NewTool\\new_vgg_unet_tool")
elif run_model == 2:
model = model_from_checkpoint_path("..\\Checkpoints\\NewTool\\new_resnet_unet_tool")
elif run_model == 3:
model = model_from_checkpoint_path("..\\Checkpoints\\NewTool\\new_unet_tool")
if save_video == "Y":
try:
out_vid = cv2.VideoWriter('..\\OutputVideo\\Degree.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 3, (960, 540))
except cv2.error as e:
print("cv2.error:", e)
except Exception as e:
print("Exception:", e)
else:
help="(Relative) path to input image file")
parser.add_argument(
"--output_folder",
default='',
help=
"(Relative) path to output image file. If empty, image is not written."
)
parser.add_argument(
"--display",
default=False,
help="Whether to display video on screen (can be slow)")
args = parser.parse_args()
#Load model
model = predict.model_from_checkpoint_path(args.model_prefix, args.epoch)
while not rospy.is_shutdown():
print('Output_folder', args.output_folder)
im_files = glob.glob(os.path.join(args.input_folder, '*.jpg'))
print(os.path.join(args.input_folder + '*.png'))
for im in sorted(im_files):
if args.output_folder:
base = os.path.basename(im)
output_file = os.path.join(
args.output_folder,
os.path.splitext(base)[0]) + "_pred.png"
print(output_file)
else:
output_file = None
from keras_segmentation.predict import model_from_checkpoint_path
from tensorflow.compat.v1 import InteractiveSession
from tensorflow.compat.v1 import ConfigProto
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)
model = model_from_checkpoint_path("/home/klz/checkpoints/vgg_unet_1")
out = model.predict_multiple(inp_dir="/home/klz/unlabeled_food_images/",
out_dir="/home/klz/unlabeled_food_annotations/",
colors=[(0, 0, 0), (255, 255, 255)])
# import matplotlib.pyplot as plt
# plt.imshow(out)
# print(model.evaluate_segmentation( inp_images_dir="/home/klz/food_test_images/",
# annotations_dir="/home/klz/food_test_annotations/" ) )
parser.add_argument('--prediction_in', help='Path to the test images', required=True, default=None)
parser.add_argument('--prediction_out', help='Path to the output csv files folder', required=True, default=None)
parser.add_argument('--prediction_tmp', help='Path to the temporary csv files folder', required=False, default=None)
parser.add_argument('--continuous', action='store_true', help='Whether to continuously load test images and perform prediction', required=False, default=False)
parser.add_argument('--delete_input', action='store_true', help='Whether to delete the input images rather than move them to --prediction_out directory', required=False, default=False)
parser.add_argument('--clash_suffix', help='The file name suffix to use in case the input file is already a PNG and moving it to the output directory would overwrite the prediction PNG', required=False, default="-in")
parser.add_argument('--memory_fraction', type=float, help='Memory fraction to use by tensorflow, i.e., limiting memory usage', required=False, default=0.5)
parsed = parser.parse_args()
try:
# apply memory usage
print("Using memory fraction: %f" % parsed.memory_fraction)
config = tf.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = parsed.memory_fraction
set_session(tf.Session(config=config))
# load model
model_dir = os.path.join(parsed.checkpoints_path, '')
print("Loading model from %s" % model_dir)
model = model_from_checkpoint_path(model_dir)
# predict
while True:
predict_on_images(model, parsed.prediction_in, parsed.prediction_out, parsed.prediction_tmp,
parsed.delete_input, clash_suffix=parsed.clash_suffix)
if not parsed.continuous:
break
except Exception as e:
print(traceback.format_exc())
def predict(self,
model=None,
inp=None,
out_fname=None,
checkpoints_path=None,
clrs=None,
out_prob_file=None):
"""Make prediction from an img and loaded model"""
if model is None and (checkpoints_path is not None):
model = model_from_checkpoint_path(checkpoints_path)
assert inp is not None
assert isinstance(inp, (np.ndarray, six.string_types)), \
"Input should be the CV image or the input file name"
if isinstance(inp, six.string_types):
inp = cv2.imread(inp)
assert len(inp.shape) == 3, "Image should be h,w,3 "
orininal_h = inp.shape[0]
orininal_w = inp.shape[1]
output_width = model.output_width
output_height = model.output_height
input_width = model.input_width
input_height = model.input_height
n_classes = model.n_classes
img_ar = get_image_array(inp,
input_width,
input_height,
ordering=IMAGE_ORDERING)
pred = model.predict(np.array([img_ar]))[0]
# Creating probabilities file
if out_prob_file is not None:
out_prob_file += "_prob_{}x{}.csv".format(output_width,
output_height)
with open(out_prob_file, 'w+') as file:
# Header
header = "x y "
for i in range(0, n_classes):
header += "C{} ".format(str(i))
header += "class\n"
file.write(header)
# Pixel per pixel
coord_x = 0
coord_y = 0
for pixel in pred:
line = "{} {}".format(coord_x, coord_y)
for class_prob in pixel:
line += " {}".format(str(class_prob))
line += " {}".format(str(np.argmax(pixel))) + "\n"
file.write(line)
coord_x += 1
if coord_x >= output_width:
coord_x = 0
coord_y += 1
pred = pred.reshape(
(output_height, output_width, n_classes)).argmax(axis=2)
seg_img = np.zeros((output_height, output_width, 3))
if clrs is None:
colors = class_colors
else:
colors = clrs
for color in range(n_classes):
seg_img[:, :, 0] += ((pred[:, :] == color) * (colors[color][0])) \
.astype('uint8')
seg_img[:, :, 1] += ((pred[:, :] == color) * (colors[color][1])) \
.astype('uint8')
seg_img[:, :, 2] += ((pred[:, :] == color) * (colors[color][2])) \
.astype('uint8')
seg_img = cv2.resize(seg_img, (orininal_w, orininal_h))
if out_fname is not None:
cv2.imwrite(out_fname, seg_img)
return pred
parser.add_argument(
"--inp_path",
default=os.path.expanduser('~') +
"/Third_Paper/Datasets/Frogn_Dataset/images_prepped_test/frogn_10000.png")
parser.add_argument("--pre_trained", default="True", type=bool)
parser.add_argument("--predict_multiple_images", default="False", type=bool)
args = parser.parse_args()
model = keras_segmentation.models.segnet.segnet(n_classes=4,
input_height=320,
input_width=640)
#pre_trained = True
#predict_multiple_images = False
if args.pre_trained:
model = model_from_checkpoint_path(args.model_path)
else:
model.train(train_images=args.train_images_path,
train_annotations=args.train_annotations_path,
checkpoints_path=args.model_path,
epochs=5)
if args.predict_multiple_images:
out = model.predict_multiple(inp_dir=args.inp_dir_path,
checkpoints_path=args.model_path,
out_dir=args.out_dir_path)
else:
out = model.predict_segmentation(inp=args.inp_path,
checkpoints_path=args.model_path,
colors = class_colors
for c in range(3): # with 3 classes
seg_img[:, :, 0] += ((img[:, :] == c) * (colors[c][0])).astype('uint8')
seg_img[:, :, 1] += ((img[:, :] == c) * (colors[c][1])).astype('uint8')
seg_img[:, :, 2] += ((img[:, :] == c) * (colors[c][2])).astype('uint8')
seg_img = cv2.resize(seg_img, (640, 408))
return seg_img
videoFilePath = "..\\..\\RealTime Video\\CV_2_cropped.mp4"
model = model_from_checkpoint_path("..\\..\\Checkpoints\\AllTools\\mobilenet_alltools")
cap = cv2.VideoCapture(videoFilePath)
i = 0
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
dim = (960, 540)
frame = cv2.resize(frame, dim, interpolation=cv2.INTER_LINEAR)
if (i % 5) == 0:
out = model.predict_segmentation(inp=frame)
img = convertNumpyArrayToMat(out)
import tensorflow as tf
from keras_segmentation.predict import predict_multiple
from keras_segmentation.predict import model_from_checkpoint_path
gpu_devices = tf.config.experimental.list_physical_devices('GPU')
for device in gpu_devices: tf.config.experimental.set_memory_growth(device, True)
print(f"[INFO] Predicting on test set mask..")
pdr=predict_multiple(
checkpoints_path=r"C:\Users\matte\PycharmProjects\ecographic_breast_nn\segnet\checkpoints\psp_unet",
inp_dir=r"D:\FISICA MEDICA\radiomics_eco\Dataset_BUSI_with_GT\segnet\images_val",
out_dir=r"C:\Users\matte\PycharmProjects\ecographic_breast_nn\segnet\outputs"
)
model=model_from_checkpoint_path(r"C:\Users\matte\PycharmProjects\ecographic_breast_nn\segnet\checkpoints\psp_unet")
print(f"[INFO] Evaluating model..")
print(model.evaluate_segmentation( inp_images_dir=r"D:\FISICA MEDICA\radiomics_eco\Dataset_BUSI_with_GT\segnet\images_val" , annotations_dir=r"D:\FISICA MEDICA\radiomics_eco\Dataset_BUSI_with_GT\segnet\masks_val" ) )
def main():
parser = argparse.ArgumentParser(
description=
"Example: Run prediction on an image folder. Example usage: python lane_predict.py --model_prefix=models/resnet_3class --epoch=25 --input_folder=Frogn_Dataset/images_prepped_test --output_folder=."
)
parser.add_argument("--model_prefix",
default='',
help="Prefix of model filename")
parser.add_argument("--epoch",
default=None,
help="Checkpoint epoch number")
parser.add_argument("--input_folder",
default='',
help="(Relative) path to input image file")
parser.add_argument(
"--output_folder",
default='',
help=
"(Relative) path to output image file. If empty, image is not written."
)
parser.add_argument(
"--display",
default=False,
help="Whether to display video on screen (can be slow)")
args = parser.parse_args()
#Load model
model = predict.model_from_checkpoint_path(args.model_prefix, args.epoch)
print('Output_folder', args.output_folder)
im_files = glob.glob(os.path.join(args.input_folder, '*.jpg'))
print(os.path.join(args.input_folder + '*.jpg'))
for im in im_files:
if args.output_folder:
base = os.path.basename(im)
output_file = os.path.join(
args.output_folder,
os.path.splitext(base)[0]) + "_da_pred.png" #
print(output_file)
else:
output_file = None
seg_arr, input_image, out_img, fit = predict_on_image(
model,
inp=im,
lane_fit=False,
evaluate=False,
visualize="segmentation",
output_file=output_file,
display=True)
vis_img = visualization(input_image,
seg_arr=seg_arr,
lane_fit=None,
evaluation=None,
n_classes=3,
visualize="segmentation",
display=False,
output_file=output_file)
#
# print(timeit.timeit(stmt = "for_loop(seq)",
# setup="seq='Pylenin'",
# number=10000))
#print(timeit.timeit(predict_on_image(model,inp = im, lane_fit = False, evaluate = False, visualize = "segmentation", output_file = output_file, display=True)))
print("--- %s seconds ---" % (time.time() - start_time))
cv2.destroyAllWindows()
import cv2
from keras_segmentation.predict import predict, model_from_checkpoint_path
import random
#https://divamgupta.com/image-segmentation/2019/06/06/deep-learning-semantic-segmentation-keras.html
model = model_from_checkpoint_path("checkpoints/resnet50_unet_1")
cap = cv2.VideoCapture("test.mp4")
if (cap.isOpened() == False):
print("Error opening video stream or file")
while (cap.isOpened()):
ret, frame = cap.read()
if ret == True:
mask, mask_image = predict(model=model, inp=frame)
cv2.imshow('Frame', mask_image)
# Press Q on keyboard to exit
if cv2.waitKey(25) & 0xFF == ord('q'):
break
else:
break
cap.release()
cv2.destroyAllWindows()
def main():
# Setup the training parameters, input paths etc.,
checkpoints_path = "./checkpoints_mobilenet_unet_2class/"
test_images_path = "./dataset2/images_prepped_test/"
test_masks_path = "./dataset2/masks_prepped_test_2class/"
predicted_masks_path = "./dataset2/masks_predicted/"
predicted_overlay_path = "./dataset2/overlay_predicted/"
# Enable printing of IoU scores for tests.
print_test_results = 0
# Model checkpoint path should exist, else it is an error.
if not os.path.exists(checkpoints_path):
print("[ERROR] invalid checkpoints path {}".format(checkpoints_path))
sys.exit(1)
# Get Intersection over Union (IoU) results for the test data set.
# The model is picked up from the latest model in the checkpoints_path.
# The input images and masks (masks) are picked up from their paths.
if print_test_results:
test_results = evaluate(inp_images_dir=test_images_path,
masks_dir=test_masks_path,
checkpoints_path=checkpoints_path)
print(test_results)
print("Test results complete")
# Create output directory to store predicted masks and overlays.
# Remove any existing png files.
if not os.path.exists(predicted_masks_path):
os.makedirs(predicted_masks_path)
if not os.path.exists(predicted_overlay_path):
os.makedirs(predicted_overlay_path)
for f in glob.glob(predicted_masks_path + '/*.png'):
os.remove(f)
for f in glob.glob(predicted_overlay_path + '/*.png'):
os.remove(f)
# Predict results for the input images and store in output directory.
# Store both the predicted masks and the overlaid images with masks.
# Step 1. Load model from checkpoint path.
model = model_from_checkpoint_path(checkpoints_path)
# Step 2. Read images one by one and feed it in into predict function.
# Output predicted mask is written to the predicted masks directory.
# Assume that input images are in png format.
for infile in glob.glob(test_images_path + '/*.png'):
filename = os.path.split(infile)[1]
outfile = os.path.join(predicted_masks_path, filename)
overlayfile = os.path.join(predicted_overlay_path, filename)
print("Predicting mask for file {}, output in {}".format(
infile, outfile))
# Create predicted mask from input file, and store it in outfile.
predict(inp=infile, out_fname=outfile, model=model)
# Overlay the predicted mask file over input file for display.
overlay_image_with_mask(image_file=infile,
mask_file=outfile,
overlay_file=overlayfile)
print("Prediction complete")
output_name = 'prediction_overlay'
#model
checkpoints_path = os.path.join('../models', 'resnet50_segnet')
epoch = 20
figure_dpi = 300
figure_width_mm = 88.57
image_spacing_mm = figure_width_mm * 0.05
print(len(inp_names))
figure_height_mm = (
(176 * len(inp_names) * 1.25) /
(320 * 2 * 1.05)) * figure_width_mm #Adjusting height to get a tight fit
#Load model first
model = model_from_checkpoint_path(checkpoints_path, epoch)
#Save one at a time as image
for ind, fname in enumerate(inp_names):
#Load images
inp = os.path.join(image_folder, fname)
ann = os.path.join(annotations_folder, fname)
#Run prediction
pr = predict_fast(model, inp)
gt = get_segmentation_arr(ann,
model.n_classes,
model.output_width,
model.output_height,
no_reshape=True)
gt = gt.argmax(-1)
