def show_result(img_path, result):
outputs_dict = result.outputs
classes_tensor = string_tensor_to_list(outputs_dict["classes"])
converted_classes = np.array([convert_class(x) for x in classes_tensor])
bboxes_tensor = outputs_dict["bboxes"]
scores_tensor = outputs_dict["scores"]
img = mpimg.imread(img_path)
plt_bboxes(
img,
converted_classes,
double_tensor_to_list(scores_tensor),
double_tensor_to_list(bboxes_tensor),
)
def cut(img_path):
img = mpimg.imread(img_path)
_dir, _name = os.path.split(img_path)
rclasses, rscores, rbboxes = process_image(img)
cut_img = visualization.plt_bboxes(_dir, _name[:-4], img, rclasses,
rscores, rbboxes)
return cut_img
def eval_ssd(image_path=None):
print('=> Evaluating SSD...')
if image_path == None:
print("Image Path not speficied")
sys.exit(1)
img = mpimg.imread(image_path)
# Run SSD network.
starttime = time.time()
rimg, rpredictions, rlocalizations, rbbox_img = isess.run(
[image_4d, predictions, localizations, bbox_img],
feed_dict={img_input: img})
print("--- %s seconds ---" % (time.time() - starttime))
# Get classes and bboxes from the net outputs.
rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select(
rpredictions,
rlocalizations,
ssd_anchors,
select_threshold=0.0,
img_shape=net_shape,
num_classes=num_classes,
decode=True)
rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes)
rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses,
rscores,
rbboxes,
top_k=400)
rclasses, rscores, rbboxes = np_methods.bboxes_nms(rclasses,
rscores,
rbboxes,
nms_threshold=0.0)
# Resize bboxes to original image shape. Note: useless for Resize.WARP!
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
### visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
visualization.plt_bboxes(img, rclasses, rscores, rbboxes, dataset_name)
pred_list = visualization.save_as_JSON(img, rclasses, rscores, rbboxes,
dataset_name)
return pred_list
def show_image(fname, pred):
image = cv2.cvtColor(cv2.imread(fname), cv2.COLOR_BGR2RGB)
predictions = [np.expand_dims(n, 0) for n in pred.values()]
rpredictions = predictions[:6]
rlocalisations = predictions[6:]
ssd_anchors = create_default_boxes()
rclasses, rscores, rbboxes = ssd_bboxes_select(
rpredictions,
rlocalisations,
ssd_anchors,
select_threshold=Config.predict.select_threshold,
decode=True)
rbboxes = bboxes_clip(rbboxes)
rclasses, rscores, rbboxes = bboxes_sort(rclasses,
rscores,
rbboxes,
top_k=400)
rclasses, rscores, rbboxes = bboxes_nms(
rclasses, rscores, rbboxes, nms_threshold=Config.predict.nms_threshold)
visualization.plt_bboxes(image, rclasses, rscores, rbboxes)
def upload_file():
if request.method == 'POST':
file = request.files['file']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
file_url = url_for('uploaded_file', filename=filename)
img = mpimg.imread(filename)
rclasses, rscores, rbboxes = process_image(img)
fig = visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
new_filename = "%s.png" % (filename.split('.')[0] + '_result')
fig.savefig(new_filename)
new_file_url = url_for('uploaded_file', filename=new_filename)
#new_file_url = url_for('uploaded_file', filename='test.png')
return html + '<table><tr><td><img src=' + file_url + ' border=0></td> <td><img src=' + new_file_url + ' border=0></td> </tr></table>'
return html
"""
import cv2
import numpy as np
import tensorflow as tf
import matplotlib.image as mpimg
from ssd_300_vgg import SSD
from utils import preprocess_image, process_bboxes
from visualization import plt_bboxes
ssd_net = SSD()
classes, scores, bboxes = ssd_net.detections()
images = ssd_net.images()
sess = tf.Session()
# Restore SSD model.
ckpt_filename = './ssd_checkpoints/ssd_vgg_300_weights.ckpt'
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, ckpt_filename)
img = cv2.imread('./demo/dog.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_prepocessed = preprocess_image(img)
rclasses, rscores, rbboxes = sess.run([classes, scores, bboxes],
feed_dict={images: img_prepocessed})
rclasses, rscores, rbboxes = process_bboxes(rclasses, rscores, rbboxes)
plt_bboxes(img, rclasses, rscores, rbboxes)
#print(image_names)
#img = mpimg.imread(image_path + image_names[1])
predict_result = predict_test(1, serving_config, img)
print("--------------------------------")
predictions = []
localisations = []
# get result
predictions.append(parse_result_value(predict_result, 'predictions0'))
predictions.append(parse_result_value(predict_result, 'predictions1'))
predictions.append(parse_result_value(predict_result, 'predictions2'))
predictions.append(parse_result_value(predict_result, 'predictions3'))
predictions.append(parse_result_value(predict_result, 'predictions4'))
predictions.append(parse_result_value(predict_result, 'predictions5'))
localisations.append(parse_result_value(predict_result, 'localisations0'))
localisations.append(parse_result_value(predict_result, 'localisations1'))
localisations.append(parse_result_value(predict_result, 'localisations2'))
localisations.append(parse_result_value(predict_result, 'localisations3'))
localisations.append(parse_result_value(predict_result, 'localisations4'))
localisations.append(parse_result_value(predict_result, 'localisations5'))
bbox_img_0 = parse_result_value(predict_result, 'bbox_img')
rclasses, rscores, rbboxes = process_image_1(predictions, localisations,
bbox_img_0)
visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
#print(predict_result.outputs['predictions0'].float_val)
#curl -d '{"instances": [[[1,1,1]]]}' -X POST http://localhost:8501/v1/models/testnet:predict
def main(ckpt, img_path):
# 1 定义输入数据的占位符
image_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
# 2 数据输入到预处理工厂当中，进行处理得到结果
# 定义一个输出的形状，元组表示
net_shape = (300, 300)
data_format = "NHWC"
preprocessing_fn = preprocessing_factory.get_preprocessing(
"ssd_vgg_300", is_training=False)
img_pre, _, _, bbox_img = preprocessing_fn(image_input, None, None,
net_shape, data_format)
# 3 定义SSD模型， 并输出预测结果
# img_pre是三维形状，(300, 300, 3)
# 卷积神经网络要求都是四维的数据计算(1, 300, 300, 3)
# 维度的扩充
image_4d = tf.expand_dims(img_pre, 0)
# reuse作用：在notebook当中运行，第一次创建新的变量为FALSE，但是重复运行cell,保留这些变量的命名，选择重用这些命名，已经存在内存当中了
# 没有消除，设置reuse=True
reuse = True if 'ssd_net' in locals() else False
# 网络工厂获取
ssd_class = nets_factory.get_network("ssd_vgg_300")
ssd_params = ssd_class.default_params._replace(num_classes=3)
# 初始化网络
ssd_net = ssd_class(ssd_params)
# 通过网络的方法获取结果
# 使用slim.arg_scope指定共有参数data_format,net里面有很多函数需要使用data_format
with slim.arg_scope(ssd_net.arg_scope(data_format=data_format)):
predictions, localisations, _, _ = ssd_net.net(image_4d,
is_training=False,
reuse=reuse)
# 4 定义交互式会话，初始化变量，加载模型
#4.1 使用config定义一个交互式会话
config = tf.ConfigProto(log_device_placement=False)
sess = tf.InteractiveSession(config=config)
#4.2 初始化变量
sess.run(tf.global_variables_initializer())
#4.3 加载模型
# 训练参数
ckpt_filepath = ckpt
# 创建saver
saver = tf.train.Saver()
saver.restore(sess, ckpt_filepath)
# 4.4 得到模型预测结果
# 读取一张图片
img = Image.open(img_path).convert('RGB')
start = time.time()
i, p, l, box_img = sess.run(
[image_4d, predictions, localisations, bbox_img],
feed_dict={image_input: img})
#print(p)
# 5 预测结果后期处理
# 通过 predictions 与 select_threshold 筛选bbox
ssd_anchors = ssd_net.anchors(net_shape)
#5.1 去掉概率小于select_threshold的检测框
classes, scores, bboxes = np_methods.ssd_bboxes_select(
p,
l,
ssd_anchors,
select_threshold=0.4,
img_shape=(300, 300),
num_classes=3,
decode=True)
#5.2 bbox边框不能超过原图片 默认原图的相对于bbox大小比例 [0, 0, 1, 1]
bboxes = np_methods.bboxes_clip([0, 0, 1, 1], bboxes)
#5.3 NMS
# 根据 scores 从大到小排序，并改变classes rbboxes的顺序
classes, scores, bboxes = np_methods.bboxes_sort(classes,
scores,
bboxes,
top_k=400)
# 使用nms算法筛选bbox
classes, scores, bboxes = np_methods.bboxes_nms(classes,
scores,
bboxes,
nms_threshold=.45)
# 根据原始图片的bbox，修改所有bbox的范围 [.0, .0, .1, .1]
bboxes = np_methods.bboxes_resize([.0, .0, .1, .1], bboxes)
end = time.time()
print("Predicted in %f seconds" % (end - start))
#6 预测结果显示
img = np.array(img)
visualization.plt_bboxes(img, classes, scores, bboxes)
def robot_player(color_image, depth_image):
rclasses, rscores, rbboxes = process_image(color_image)
visualization.plt_bboxes(color_image, rclasses, rscores, rbboxes)
if(len(rclasses)==0):
return
count = 0
while count < len(rclasses):
ymin = int(rbboxes[count][0]*color_image.shape[0])
xmin = int(rbboxes[count][1]*color_image.shape[1])
ymax = int(rbboxes[count][2]*color_image.shape[0])
xmax = int(rbboxes[count][3]*color_image.shape[1])
if (xmax < 450 or xmin > 1000):
count = count + 1
continue
# crop_img = color_image[ymin-10:ymax+10,xmin-10:xmax+10,:]
# minRect = compute_minRect(crop_img)
# final_rect = []
# final_rect = non_maximum_suppression(crop_img,minRect)
# if len(minRect) == 0:
# count = count + 1
# print 'No Objects'
# continue
# # find the x, y, z of the pick point in the camera coordinate
z = 0.9927
x = (0-624.79)/931.694*z
y = (0-360.52)/931.463*z
grasp = PoseStamped()
grasp.pose.position.x = x
grasp.pose.position.y = y
grasp.pose.position.z = z
# #pick = tf2_geometry_msgs.do_transform_pose(grasp, trans)
#pick.pose.position.z += 0.076 # offset for tool0 to the suction cup 0.13
pick_point = [(xmin+xmax)/2,(ymin+ymax)/2]
# angle = (0 + minRect[0][2])*3.14/180
angle = 0
print 'angle: ',angle
grasp_point = np.array([[pick_point]], dtype=np.float32)
gp_base = cv2.perspectiveTransform(grasp_point, image2baseMatrix)
pick = PoseStamped()
pick.header.frame_id = "world"
pick.pose.position.z = 0.134
pick.pose.position.x = gp_base[0][0][0]/1000.0
pick.pose.position.y = gp_base[0][0][1]/1000.0
pick.pose.orientation.x = 1
pick.pose.orientation.y = 0
pick.pose.orientation.z = 0
pick.pose.orientation.w = 0
set_states()
pick.pose.position.z = pick.pose.position.z + 0.05
group.set_pose_target(pick, end_effector_link='tool0') #wrist3_Link
plan = group.plan()
raw_input('Press enter to go pick position: ')
group.execute(plan)
pick.pose.position.z = pick.pose.position.z - 0.04
pick.pose.position.x = pick.pose.position.x - 0.005
pick.pose.position.y = pick.pose.position.y - 0.005
group.set_pose_target(pick, end_effector_link='tool0')
plan = group.plan()
group.execute(plan)
time.sleep(0.2)
set_digital_out(0, False)
time.sleep(1)
pick.pose.position.z = pick.pose.position.z + 0.1
group.set_pose_target(pick, end_effector_link='tool0')
plan = group.plan()
group.execute(plan)
# raw_input('Press enter to go place position: ')
time.sleep(1)
#place joint
place_position_0 = [24.47/180*3.14, -104.60/180*3.14, -143.36/180*3.14, -22.19/180*3.14, 89.51/180*3.14, -53.94/180*3.14]
place_position_1 = [31.28/180*3.14, -105.20/180*3.14, -142.30/180*3.14, -22.70/180*3.14, 89.53/180*3.14, -53.94/180*3.14]
place_position_2 = [21.45/180*3.14, -108.54/180*3.14, -136.41/180*3.14, -25.19/180*3.14, 89.49/180*3.14, -53.94/180*3.14]
place_position_3 = [27.38/180*3.14, -108.96/180*3.14, -135.62/180*3.14, -25.59/180*3.14, 89.51/180*3.14, -53.94/180*3.14]
place_xyz_0 = PoseStamped()
place_xyz_1 = PoseStamped()
place_xyz_2 = PoseStamped()
place_xyz_3 = PoseStamped()
place_xyz_0.pose.position.z = 0.15
place_xyz_0.pose.position.x = 0.54
place_xyz_0.pose.position.y = 0.046
place_xyz_0.pose.orientation.x = 1
place_xyz_0.pose.orientation.y = 0
place_xyz_0.pose.orientation.z = 0
place_xyz_0.pose.orientation.w = 0
place_xyz_1.pose.position.z = 0.15
place_xyz_1.pose.position.x = 0.54
place_xyz_1.pose.position.y = 0.106
place_xyz_1.pose.orientation.x = 1
place_xyz_1.pose.orientation.y = 0
place_xyz_1.pose.orientation.z = 0
place_xyz_1.pose.orientation.w = 0
place_xyz_2.pose.position.z = 0.15
place_xyz_2.pose.position.x = 0.600
place_xyz_2.pose.position.y = 0.046
place_xyz_2.pose.orientation.x = 1
place_xyz_2.pose.orientation.y = 0
place_xyz_2.pose.orientation.z = 0
place_xyz_2.pose.orientation.w = 0
place_xyz_3.pose.position.z = 0.15
place_xyz_3.pose.position.x = 0.600
place_xyz_3.pose.position.y = 0.106
place_xyz_3.pose.orientation.x = 1
place_xyz_3.pose.orientation.y = 0
place_xyz_3.pose.orientation.z = 0
place_xyz_3.pose.orientation.w = 0
place_position_up = [26.0/180*3.14, -100.42/180*3.14, -139.49/180*3.14, -30.26/180*3.14, 89.51/180*3.14, -23.94/180*3.14]
place_position_mid = [99.31/180*3.14, -87.55/180*3.14, -135.44/180*3.14, -47.08/180*3.14, 89.0/180*3.14, -23.94/180*3.14]
# #
# place_0 = PoseStamped()
# place_0.pose.position.x = 0.577
# place_0.pose.position.y = 0.06
# place_0.pose.position.z = 0.048
# place_0.pose.orientation.x = 1
# place_0.pose.orientation.y = 0.0
# place_0.pose.orientation.z = 0.0
# place_0.pose.orientation.w = 0.0
# place_0_up = place_0
# place_0_up.pose.position.z += 0.01
# place_1 = place_0
# place_1.pose.position.y += 0.051
# place_1_up = place_1
# place_1_up.pose.position.z += 0.01
# place_2 = place_0
# place_2.pose.position.x += 0.051
# place_2_up = place_2
# place_2_up.pose.position.z += 0.01
# place_3 = place_0
# place_3.pose.position.x += 0.051
# place_3.pose.position.y += 0.051
# place_3_up = place_3
# place_3_up.pose.position.z += 0.01
#
# #go to up of place point
# group.set_pose_target(place_0_up, end_effector_link='tool0')
# plan = group.plan()
# raw_input('Press enter to go place position: ')
# group.execute(plan)
# time.sleep(1)
# #go to place
# group.set_pose_target(place_0, end_effector_link='tool0')
# plan = group.plan()
# raw_input('Press enter to go place position: ')
# group.execute(plan)
# time.sleep(1)
# group.set_joint_value_target(home_joint_position)
# plan = group.plan()
# raw_input('Press enter to go home position: ')
# group.execute(plan)
group.set_joint_value_target(place_position_mid)
plan = group.plan()
group.set_joint_value_target(place_position_up)
plan = group.plan()
# raw_input('Press enter to go place position: ')
group.execute(plan)
time.sleep(0.5)
jigsaw_type = rclasses[count]
if jigsaw_type == 1:
# place_position_0[5]-=angle
group.set_joint_value_target(place_position_0)
# group.set_pose_target(place_xyz_0, end_effector_link='tool0')
elif jigsaw_type == 3:
# place_position_1[5]-=angle
group.set_joint_value_target(place_position_1)
# group.set_pose_target(place_xyz_1, end_effector_link='tool0')
elif jigsaw_type == 4:
# place_position_2[5]-=angle
group.set_joint_value_target(place_position_2)
# group.set_pose_target(place_xyz_2, end_effector_link='tool0')
elif jigsaw_type == 2:
# place_position_3[5]-=angle
group.set_joint_value_target(place_position_3)
# group.set_pose_target(place_xyz_3, end_effector_link='tool0')
plan = group.plan()
# raw_input('Press enter to go the place position: ')
group.execute(plan)
time.sleep(1)
set_digital_out(0, True)
time.sleep(1)
count = count + 1
group.set_joint_value_target(place_position_up)
plan = group.plan()
group.execute(plan)
time.sleep(0.3)
group.set_joint_value_target(home_joint_position)
plan = group.plan()
raw_input('Press enter to go home position: ')
group.execute(plan)
import cv2
import numpy as np
import tensorflow as tf
import matplotlib.image as mpimg
from ssd_300_vgg import SSD
from utils import preprocess_image, process_bboxes
from visualization import plt_bboxes
ssd_net = SSD()
classes, scores, bboxes = ssd_net.detections()
images = ssd_net.images()
sess = tf.Session()
# Restore SSD model.
ckpt_filename = './ssd_checkpoints/ssd_vgg_300_weights.ckpt'
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(sess, ckpt_filename)
img = cv2.imread('./demo/dog.jpg')
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_prepocessed = preprocess_image(img)
rclasses, rscores, rbboxes = sess.run([classes, scores, bboxes],
feed_dict={images: img_prepocessed})
rclasses, rscores, rbboxes = process_bboxes(rclasses, rscores, rbboxes)
plt_bboxes(img, rclasses, rscores, rbboxes)
ckpt_filepath = "..\ckpt\\fine_tuning\model.ckpt-0"
# 创建saver
saver = tf.train.Saver()
saver.restore(sess, ckpt_filepath)
# 4.4 得到模型预测结果
# 读取一张图片
img = Image.open("0.jpg").convert('RGB')
i, p, l, box_img = sess.run([image_4d, predictions, localisations, bbox_img], feed_dict={image_input:img})
#print(p)
# 5 预测结果后期处理
# 通过 predictions 与 select_threshold 筛选bbox
ssd_anchors = ssd_net.anchors(net_shape)
#5.1 去掉概率小于select_threshold的检测框
classes, scores, bboxes = np_methods.ssd_bboxes_select(p, l, ssd_anchors, select_threshold=0.4, img_shape=(300, 300), num_classes=3, decode=True)
#5.2 bbox边框不能超过原图片 默认原图的相对于bbox大小比例 [0, 0, 1, 1]
bboxes = np_methods.bboxes_clip([0, 0, 1, 1], bboxes)
#5.3 NMS
# 根据 scores 从大到小排序，并改变classes rbboxes的顺序
classes, scores, bboxes = np_methods.bboxes_sort(classes, scores, bboxes, top_k=400)
# 使用nms算法筛选bbox
classes, scores, bboxes = np_methods.bboxes_nms(classes, scores, bboxes, nms_threshold=.45)
# 根据原始图片的bbox，修改所有bbox的范围 [.0, .0, .1, .1]
bboxes = np_methods.bboxes_resize([.0, .0, .1, .1], bboxes)
#6 预测结果显示
img=np.array(img)
visualization.plt_bboxes(img, classes, scores, bboxes)
for lvar in range(len(image_names)):
img = mpimg.imread(path + video + image_names[lvar])
start_time = time.time()
rclasses, rscores, rbboxes, network_time[lvar] = process_image(
img, 0.5, 0.45, (300, 300), True, False)
#print(rbboxes)
#plt.imshow(img)
#plt.show()
end_time = time.time()
process_time[lvar] = end_time - start_time
#visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
#visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
rimg = np.array(img)
visualization.bboxes_draw_on_img(rimg, rclasses, rscores, rbboxes,
visualization.colors_tableau)
visualization.plt_bboxes(rimg, rclasses, rscores, rbboxes,
outputpath + "complete_" + image_names[lvar])
#print(rbboxes)
#print(rclasses)
#print(rscores)
#rbboxes =np.array([[0,1,0,1],[0.46,0.14,0.74,0.56]])
if rbboxes.shape[0] >= 1:
start_time = time.time()
y1 = int(rbboxes[-1, 0] * 0.8 * img.shape[0])
x1 = int(rbboxes[-1, 1] * 0.8 * img.shape[1])
y2 = min(int(rbboxes[-1, 2] * 1.2 * img.shape[0]), img.shape[0])
x2 = min(int(rbboxes[-1, 3] * 1.2 * img.shape[1]), img.shape[1])
#print(y2-y1,x2-x1)
medium_img = np.array(img[y1:y2, x1:x2, :])
#medium_img = np.array(img)
#plt.imshow(medium_img)
#plt.show()
decode=True)
rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes)
rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses,
rscores,
rbboxes,
top_k=400)
rclasses, rscores, rbboxes = np_methods.bboxes_nms(
rclasses, rscores, rbboxes, nms_threshold=nms_threshold)
# Resize bboxes to original image shape. Note: useless for Resize.WARP!
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
return rclasses, rscores, rbboxes
# Test on some demo image and visualize output.
path = '../demo/'
image_names = sorted(os.listdir(path))
for image_name in image_names:
img = mpimg.imread(path + image_name)
ts = time.time()
rclasses, rscores, rbboxes = process_image(img)
print('execute time = ' + str(time.time() - ts) + ' (s)')
# visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
visualization.plt_bboxes(img,
rclasses,
rscores,
rbboxes,
filename=image_name.split('.')[0] + '_bbox.jpg')
# "box": [ymin, xmin, ymax, xmax]
# },
# ...
# ]
# }
# ...
# ]
# Person: person
# Animal: bird, cat, cow, dog, horse, sheep
# Vehicle: aeroplane, bicycle, boat, bus, car, motorbike, train
# Indoor: bottle, chair, dining table, potted plant, sofa, tv/monitor
if __name__ == "__main__":
# Test on some demo image and visualize output.
path = '../BF_Segmentation/DAVIS/images/scooter-black'
path = 'testtttt'
image_names = sorted(
[file for file in os.listdir(path) if file.endswith(".jpg")])
max_len = len(image_names)
need_frames = 30
for i in range(0, min(need_frames - 1, max_len)):
img = mpimg.imread(os.path.join(path, image_names[i]))
rclasses, rscores, rbboxes = process_image(
img
) # defined above in this file, go through every image frame in specified path
# visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
visualization.plt_bboxes(img, rclasses, rscores,
rbboxes) # from visualization folder
else:
#img = cv2.imread('messi5.jpg',0)
path = '../demo/'
mage_names = sorted(os.listdir(path))
img = cv2.imread(path + image_names[-5], 1)
rclasses, rscores, rbboxes = process_image(img)
# visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
#visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_tableau, class2label, thickness=2)
cv2.imshow('image', img)
cv2.waitKey(0) & 0xFF == ord('q')
cv2.destroyAllWindows()
'''
# ----------------------------------------------------------------------------
'''
# Test on some demo image and visualize output.
path = '../demo/'
image_names = sorted(os.listdir(path))
img = mpimg.imread(path + image_names[-5])
rclasses, rscores, rbboxes = process_image(img)
# visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
'''
def ssd_test(path):
# Input Placeholder
img_input = tf.placeholder(tf.uint8, shape= (None, None, 3))
# Evaluation pre-processing: resize to ssd net shape
image_pre, labels_pre, bbox_pre, bbox_img = ssd_vgg_preprocessing.preprocess_for_eval(img_input,
None, None, net_shape, data_format,
resize= ssd_vgg_preprocessing.Resize.WARP_RESIZE)
image_4d = tf.expand_dims(image_pre, axis=0)
# Define the SSD model
reuse = True if 'ssd_net' in locals() else None
ssd_net = ssd_vgg_300.SSDNet()
with slim.arg_scope(ssd_net.arg_scope(data_format= data_format)):
predictions, localizations, _, _ = ssd_net.net(image_4d, is_training= False, reuse = reuse)
# SSD default anchor boxes
ssd_anchors = ssd_net.anchors(net_shape)
# Main image processing pipeline
# Tensorflow Session: grow memeory when needed, do not allow full GPU usage
gpu_options = tf.GPUOptions(allow_growth = True)
config = tf.ConfigProto(log_device_placement = False, gpu_options = gpu_options)
isess = tf.InteractiveSession(config = config)
# Restore the SSD model
isess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(isess, ckpt_filename)
# Run the SSD network
def post_process(img, select_thresh=0.5, nms_thresh=0.45):
rimg, rpredictions, rlocalizations, rbbox_img = isess.run([image_4d, predictions, localizations, bbox_img],
feed_dict= {img_input: img})
# get the classes and bboxes from the output
rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select(rpredictions, rlocalizations,
ssd_anchors, select_threshold=select_thresh,
img_shape = net_shape, num_classes = 21,
decode = True)
rbboxes = np_methods.bboxes_clip(rbbox_img, rbboxes)
rclasses, rscores, rbboxes = np_methods.bboxes_sort(rclasses, rscores, rbboxes, top_k = 400)
rclasses, rscores, rbboxes = np_methods.bboxes_nms(rclasses, rscores, rbboxes, nms_threshold = nms_thresh)
# Resize the bboxes to the original image sizes, but useless for Resize.WARP
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
return rclasses, rscores, rbboxes
imgs = os.listdir(path)
for i in range(len(imgs)):
img_path = os.path.join(path, imgs[i])
img = mpimg.imread(img_path)
rclasses, rscores, rbboxes = post_process(img)
visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
