def predict(dataset_name, input_path, output_path, rot90=0):
global predictor_state
if predictor_state is None:
predictor_state = PredictorState(dataset_name)
label_margin = 186
batch_size, num_channels, input_height, input_width = predictor_state.input_dims
image = cv2.imread(input_path, 1).astype(np.float32) - predictor_state.dataset.mean_pixel
if image is None:
return
image = rotate_image(image, rot90)
image_size = image.shape
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
image = cv2.copyMakeBorder(image, label_margin, label_margin,
label_margin, label_margin,
cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + \
(1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + \
(1 if image_size[1] % output_width else 0)
prediction = []
for h in range(num_tiles_h):
col_prediction = []
for w in range(num_tiles_w):
offset = [output_height * h,
output_width * w]
tile = image[offset[0]:offset[0] + input_height,
offset[1]:offset[1] + input_width, :]
margin = [0, input_height - tile.shape[0],
0, input_width - tile.shape[1]]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1],
margin[2], margin[3],
cv2.BORDER_REFLECT_101)
predictor_state.caffe_in[0] = tile.transpose([2, 0, 1])
out = predictor_state.net.forward_all(**{predictor_state.net.inputs[0]: predictor_state.caffe_in})
prob = out["prob"][0]
col_prediction.append(prob)
# print("concat row")
col_prediction = np.concatenate(col_prediction, axis=2)
prediction.append(col_prediction)
prob = np.concatenate(prediction, axis=1)
prob = util.interp_map(prob, predictor_state.dataset.zoom, image_size[1], image_size[0])
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
color_image = predictor_state.dataset.palette[prediction.ravel()].reshape(image_size)
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
color_image = rotate_image(color_image, -rot90)
print("Writing", output_path)
cv2.imwrite(output_path, color_image)
def predict(dataset_name, input_path, output_path):
dataset = Dataset(dataset_name)
net = caffe.Net(dataset.model_path, dataset.pretrained_path, caffe.TEST)
label_margin = 186
input_dims = net.blobs['data'].shape
batch_size, num_channels, input_height, input_width = input_dims
caffe_in = np.zeros(input_dims, dtype=np.float32)
image = cv2.imread(input_path, 1).astype(np.float32) - dataset.mean_pixel
image_size = image.shape
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
image = cv2.copyMakeBorder(image, label_margin, label_margin,
label_margin, label_margin,
cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + \
(1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + \
(1 if image_size[1] % output_width else 0)
prediction = []
for h in range(num_tiles_h):
col_prediction = []
for w in range(num_tiles_w):
offset = [output_height * h,
output_width * w]
tile = image[offset[0]:offset[0] + input_height,
offset[1]:offset[1] + input_width, :]
margin = [0, input_height - tile.shape[0],
0, input_width - tile.shape[1]]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1],
margin[2], margin[3],
cv2.BORDER_REFLECT_101)
caffe_in[0] = tile.transpose([2, 0, 1])
out = net.forward_all(**{net.inputs[0]: caffe_in})
prob = out['prob'][0]
col_prediction.append(prob)
# print('concat row')
col_prediction = np.concatenate(col_prediction, axis=2)
prediction.append(col_prediction)
prob = np.concatenate(prediction, axis=1)
if dataset.zoom > 1:
prob = util.interp_map(prob, dataset.zoom, image_size[1], image_size[0])
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
color_image = dataset.palette[prediction.ravel()].reshape(image_size)
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
print('Writing', output_path)
cv2.imwrite(output_path, color_image)
def predict(dataset_name, input_path, output_path):
dataset = Dataset(dataset_name)
net = caffe.Net(dataset.model_path, dataset.pretrained_path, caffe.TEST)
label_margin = 186
input_dims = net.blobs["data"].shape
batch_size, num_channels, input_height, input_width = input_dims
caffe_in = np.zeros(input_dims, dtype=np.float32)
image = cv2.imread(input_path, 1).astype(np.float32) - dataset.mean_pixel
image_size = image.shape
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
image = cv2.copyMakeBorder(image, label_margin, label_margin, label_margin, label_margin, cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + (1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + (1 if image_size[1] % output_width else 0)
prediction = []
for h in range(num_tiles_h):
col_prediction = []
for w in range(num_tiles_w):
offset = [output_height * h, output_width * w]
tile = image[offset[0] : offset[0] + input_height, offset[1] : offset[1] + input_width, :]
margin = [0, input_height - tile.shape[0], 0, input_width - tile.shape[1]]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1], margin[2], margin[3], cv2.BORDER_REFLECT_101)
caffe_in[0] = tile.transpose([2, 0, 1])
out = net.forward_all(**{net.inputs[0]: caffe_in})
prob = out["prob"][0]
col_prediction.append(prob)
# print('concat row')
col_prediction = np.concatenate(col_prediction, axis=2)
prediction.append(col_prediction)
prob = np.concatenate(prediction, axis=1)
if dataset.zoom > 1:
prob = util.interp_map(prob, dataset.zoom, image_size[1], image_size[0])
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
color_image = dataset.palette[prediction.ravel()].reshape(image_size)
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
print("Writing", output_path)
cv2.imwrite(output_path, color_image)
def predict(dataset_name, input_path, output_path, weights):
import os
dataset = Dataset(dataset_name)
if weights is None:
print('Load pre-trained weights from %s' % (dataset.pretrained_path))
# net = caffe.Net(dataset.model_path, dataset.pretrained_path, caffe.TEST)
model_path = os.path.join('training', 'frontend_vgg_test_net.txt')
net = caffe.Net(model_path, dataset.pretrained_path, caffe.TEST)
else:
print('Load weights from %s' % (weights))
net = caffe.Net(dataset.model_path, weights, caffe.TEST)
# model_path = os.path.join('models', 'frontend_vgg_deploy.prototxt')
# net = caffe.Net(model_path, dataset.pretrained_path, caffe.TEST)
label_margin = 186
input_dims = net.blobs['data'].shape
batch_size, num_channels, input_height, input_width = input_dims
caffe_in = np.zeros(input_dims, dtype=np.float32)
image_ori = cv2.imread(input_path, 1).astype(
np.float32) - dataset.mean_pixel
image_size = image_ori.shape
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
image = cv2.copyMakeBorder(image_ori, label_margin, label_margin,
label_margin, label_margin,
cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + \
(1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + \
(1 if image_size[1] % output_width else 0)
prediction = []
for h in range(num_tiles_h):
col_prediction = []
for w in range(num_tiles_w):
offset = [output_height * h, output_width * w]
tile = image[offset[0]:offset[0] + input_height,
offset[1]:offset[1] + input_width, :]
margin = [
0, input_height - tile.shape[0], 0, input_width - tile.shape[1]
]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1], margin[2],
margin[3], cv2.BORDER_REFLECT_101)
caffe_in[0] = tile.transpose([2, 0, 1])
out = net.forward_all(**{net.inputs[0]: caffe_in})
# net.blobs['data'].data[...] = caffe_in
# out = net.forward()
prob = out['prob'][0]
col_prediction.append(prob)
# print('concat row')
col_prediction = np.concatenate(col_prediction, axis=2)
prediction.append(col_prediction)
prob = np.concatenate(prediction, axis=1)
if dataset.zoom > 1:
prob = util.interp_map(prob, dataset.zoom, image_size[1],
image_size[0])
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
color_image = dataset.palette[prediction.ravel()].reshape(image_size)
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
print('Writing', output_path)
cv2.imwrite(output_path, color_image)
# import os
# output_path = os.path.join( os.path.dirname(output_path), 'overlayed_' + os.path.basename(output_path) )
output_path = ''.join(*output_path.split('.')[:-1]) + '_overlayed.png'
overlay_image = image_ori * 0.5 + color_image * 0.5
cv2.imwrite(output_path, overlay_image)
def test_image(options):
options.feat_dir = join(options.feat_dir, options.feat_layer_name)
if not exists(options.feat_dir):
os.makedirs(options.feat_dir)
label_margin = 186
if options.up:
zoom = 1
else:
zoom = 8
if options.gpu >= 0:
caffe.set_mode_gpu()
caffe.set_device(options.gpu)
print('Using GPU ', options.gpu)
else:
caffe.set_mode_cpu()
print('Using CPU')
mean_pixel = np.array(options.mean, dtype=np.float32)
net = caffe.Net(options.deploy_net, options.weights, caffe.TEST)
image_paths = [line.strip() for line in open(options.image_list, 'r')]
image_names = [split(p)[1] for p in image_paths]
input_dims = list(net.blobs['data'].shape)
assert input_dims[0] == 1
batch_size, num_channels, input_height, input_width = input_dims
print('Input size:', input_dims)
caffe_in = np.zeros(input_dims, dtype=np.float32)
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
result_list = []
feat_list = []
for i in range(len(image_names)):
print('Predicting', image_names[i])
image = cv2.imread(image_paths[i]).astype(np.float32) - mean_pixel
image_size = image.shape
print('Image size:', image_size)
image = cv2.copyMakeBorder(image, label_margin, label_margin,
label_margin, label_margin,
cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + \
(1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + \
(1 if image_size[1] % output_width else 0)
prediction = []
feat = []
for h in range(num_tiles_h):
col_prediction = []
col_feat = []
for w in range(num_tiles_w):
offset = [output_height * h,
output_width * w]
tile = image[offset[0]:offset[0] + input_height,
offset[1]:offset[1] + input_width, :]
margin = [0, input_height - tile.shape[0],
0, input_width - tile.shape[1]]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1],
margin[2], margin[3],
cv2.BORDER_REFLECT_101)
caffe_in[0] = tile.transpose([2, 0, 1])
blobs = []
if options.bin:
blobs = [options.feat_layer_name]
out = net.forward_all(blobs=blobs, **{net.inputs[0]: caffe_in})
prob = out['prob'][0]
if options.bin:
col_feat.append(out[options.feat_layer_name][0])
col_prediction.append(prob)
col_prediction = np.concatenate(col_prediction, axis=2)
if options.bin:
col_feat = np.concatenate(col_feat, axis=2)
feat.append(col_feat)
prediction.append(col_prediction)
prob = np.concatenate(prediction, axis=1)
if options.bin:
feat = np.concatenate(feat, axis=1)
if zoom > 1:
zoom_prob = util.interp_map(
prob, zoom, image_size[1], image_size[0])
else:
zoom_prob = prob[:, :image_size[0], :image_size[1]]
prediction = np.argmax(zoom_prob.transpose([1, 2, 0]), axis=2)
if options.bin:
out_path = join(options.feat_dir,
splitext(image_names[i])[0] + '.bin')
print('Writing', out_path)
write_array(out_path, feat.astype(np.float32))
feat_list.append(out_path)
out_path = join(options.result_dir,
splitext(image_names[i])[0] + '.png')
print('Writing', out_path)
cv2.imwrite(out_path, prediction)
result_list.append(out_path)
print('================================')
print('All results are generated.')
print('================================')
result_list_path = join(options.result_dir, 'results.txt')
print('Writing', result_list_path)
with open(result_list_path, 'w') as fp:
fp.write('\n'.join(result_list))
if options.bin:
feat_list_path = join(options.feat_dir, 'feats.txt')
print('Writing', feat_list_path)
with open(feat_list_path, 'w') as fp:
fp.write('\n'.join(feat_list))
def test_bin(options):
label_margin = 0
input_zoom = 8
pad = 0
if options.up:
zoom = 1
else:
zoom = 8
if options.gpu >= 0:
caffe.set_mode_gpu()
caffe.set_device(options.gpu)
print('Using GPU ', options.gpu)
else:
caffe.set_mode_cpu()
print('Using CPU')
net = caffe.Net(options.deploy_net, options.weights, caffe.TEST)
image_paths = [line.strip() for line in open(options.image_list, 'r')]
bin_paths = [line.strip() for line in open(options.bin_list, 'r')]
names = [splitext(split(p)[1])[0] for p in bin_paths]
assert len(image_paths) == len(bin_paths)
input_dims = net.blobs['data'].shape
assert input_dims[0] == 1
batch_size, num_channels, input_height, input_width = input_dims
caffe_in = np.zeros(input_dims, dtype=np.float32)
bin_test_image = read_array(bin_paths[0])
bin_test_image_shape = bin_test_image.shape
assert bin_test_image_shape[1] <= input_height and \
bin_test_image_shape[2] <= input_width, \
'input_size should be greater than bin image size {} x {}'.format(
bin_test_image_shape[1], bin_test_image_shape[2])
result_list = []
for i in range(len(image_paths)):
print('Predicting', bin_paths[i])
image = cv2.imread(image_paths[i])
image_size = image.shape
if input_zoom != 1:
image_rows = image_size[0] // input_zoom + \
(1 if image_size[0] % input_zoom != 0 else 0)
image_cols = image_size[1] // input_zoom + \
(1 if image_size[1] % input_zoom != 0 else 0)
else:
image_rows = image_size[0]
image_cols = image_size[1]
image_bin = read_array(bin_paths[i])
image_bin = image_bin[:, :image_rows, :image_cols]
top = label_margin
bottom = input_height - top - image_rows
left = label_margin
right = input_width - left - image_cols
for j in range(num_channels):
if pad == 1:
caffe_in[0][j] = cv2.copyMakeBorder(
image_bin[j], top, bottom, left, right,
cv2.BORDER_REFLECT_101)
elif pad == 0:
caffe_in[0][j] = cv2.copyMakeBorder(
image_bin[j], top, bottom, left, right,
cv2.BORDER_CONSTANT)
out = net.forward_all(**{net.inputs[0]: caffe_in})
prob = out['prob'][0]
if zoom > 1:
prob = util.interp_map(prob, zoom, image_size[1], image_size[0])
else:
prob = prob[:, :image_size[0], :image_size[1]]
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
out_path = join(options.result_dir, names[i] + '.png')
print('Writing', out_path)
cv2.imwrite(out_path, prediction)
result_list.append(out_path)
print('================================')
print('All results are generated.')
print('================================')
result_list_path = join(options.result_dir, 'results.txt')
print('Writing', result_list_path)
with open(result_list_path, 'w') as fp:
fp.write('\n'.join(result_list))
def batch_predict_kitti(dataset_name):
caffe.set_mode_gpu()
caffe.set_device(0)
img_folder = "path/to/preprocess_data/raw_imgs/"
img_list_file = "namelist_small.txt"
save_folder = "path/to/preprocess_data/"
if not os.path.exists(save_folder + "label_2d_img/"):
os.makedirs(save_folder + "label_2d_img/")
if not os.path.exists(save_folder + "label_2d_bin/"):
os.makedirs(save_folder + "label_2d_bin/")
test_img_list = np.loadtxt(img_folder + img_list_file,
str,
comments=None,
delimiter='\n')
data_counts = len(test_img_list)
print "To processing: ", data_counts
print "First one: ", test_img_list[1]
dataset = Dataset(dataset_name)
net = caffe.Net(dataset.model_path, dataset.pretrained_path, caffe.TEST)
label_margin = 186
input_dims = net.blobs['data'].shape
batch_size, num_channels, input_height, input_width = input_dims # batch is now 1.
print "Using batch size %d " % (batch_size)
for img_id in xrange(len(test_img_list)):
print "processing %d out of %d " % (img_id, len(test_img_list))
rgb_img_file = img_folder + "image_2/" + test_img_list[img_id]
saved_color_img_file = save_folder + "label_2d_img/" + test_img_list[
img_id].replace(".png", "_color.png")
saved_bw_img_file = save_folder + "label_2d_img/" + test_img_list[
img_id].replace(".png", "_bw.png")
saved_bin_file = save_folder + "label_2d_bin/" + test_img_list[
img_id].replace(".png", ".bin")
# print saved_bin_file
caffe_in = np.zeros(input_dims, dtype=np.float32)
image = cv2.imread(rgb_img_file, 1).astype(
np.float32) - dataset.mean_pixel
image_size = image.shape
output_height = input_height - 2 * label_margin
output_width = input_width - 2 * label_margin
image = cv2.copyMakeBorder(image, label_margin, label_margin,
label_margin, label_margin,
cv2.BORDER_REFLECT_101)
num_tiles_h = image_size[0] // output_height + \
(1 if image_size[0] % output_height else 0)
num_tiles_w = image_size[1] // output_width + \
(1 if image_size[1] % output_width else 0)
for h in range(num_tiles_h):
col_prediction = []
for w in range(num_tiles_w):
offset = [output_height * h, output_width * w]
tile = image[offset[0]:offset[0] + input_height,
offset[1]:offset[1] + input_width, :]
margin = [
0, input_height - tile.shape[0], 0,
input_width - tile.shape[1]
]
tile = cv2.copyMakeBorder(tile, margin[0], margin[1],
margin[2], margin[3],
cv2.BORDER_REFLECT_101)
caffe_in[0] = tile.transpose([2, 0, 1])
out = net.forward_all(**{net.inputs[0]: caffe_in})
prob = out['prob'][0]
if dataset.zoom > 1:
prob = util.interp_map(prob, dataset.zoom, image_size[1],
image_size[0])
# print prob.shape # (11, 370, 1226)
# print prob.dtype # float32
prediction = np.argmax(prob.transpose([1, 2, 0]), axis=2)
# print "prediction shape, ", prediction.shape
color_image = dataset.palette[prediction.ravel()].reshape(image_size)
color_image = cv2.cvtColor(color_image, cv2.COLOR_RGB2BGR)
# print('Writing', saved_color_img_file)
cv2.imwrite(saved_color_img_file, color_image)
cv2.imwrite(saved_bw_img_file,
prediction.astype(np.uint8)) # save as label ID image
# prob_temp=prob.transpose([1, 2, 0]) # 370*1226*11
# print prob_temp.shape
prob.transpose([1, 2, 0]).flatten().tofile(
saved_bin_file
) # save as binary file # each row store's all class probability for one pixel. pixel is ordered by row
