def run(self, result_filename, image_filename, where=None, annotation_filename=None, ann_index=0):
# 读入图片数据
final_batch_data, data_raw, gaussian_mask, ann_data, ann_mask = Data.load_image(
image_filename, where=where, annotation_filename=annotation_filename,
ann_index=ann_index, image_size=self.input_size)
# 网络
img_placeholder = tf.placeholder(dtype=tf.float32, shape=(None, self.input_size[0], self.input_size[1], 4))
net = PSPNet({'data': img_placeholder}, is_training=True, num_classes=1, last_pool_size=self.last_pool_size,
filter_number=32)
# 输出/预测
raw_output_op = net.layers["conv6_n"]
sigmoid_output_op = tf.sigmoid(raw_output_op)
# 启动Session/加载模型
sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)))
sess.run(tf.global_variables_initializer())
Tools.restore_if_y(sess, self.log_dir)
# 运行
raw_output, sigmoid_output = sess.run([raw_output_op, sigmoid_output_op], feed_dict={img_placeholder: final_batch_data})
# 保存
Image.fromarray(np.asarray(np.squeeze(data_raw), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "data.png"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(sigmoid_output[0] * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "pred.png"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(np.greater(raw_output[0], 0.5) * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "pred_raw.png"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(np.greater(sigmoid_output[0], 0.5) * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "pred_sigmoid.png"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(gaussian_mask * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "mask.bmp"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(ann_mask * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "ann.bmp"))
Tools.print_info('over : result save in {}'.format(os.path.join(self.save_dir, result_filename)))
pass
def run(self, image_filename_or_data, mask_color, opacity):
plt.ion()
plt.axis('off')
if isinstance(image_filename_or_data, str):
image_data = np.array(Image.open(image_filename_or_data))
elif isinstance(image_filename_or_data, list) or isinstance(image_filename_or_data, np.ndarray):
image_data = image_filename_or_data
else:
print("image_filename_or_data is error")
return
plt.imshow(image_data)
plt.title('Click one point of the object that you interested')
try:
while 1:
object_point = np.array(plt.ginput(1, timeout=0)).astype(np.int)[0]
where = [int(self.input_size[0] * object_point[1] / len(image_data)),
int(self.input_size[1] * object_point[0] / len(image_data[0]))]
print("point=[{},{}] where=[{},{}]".format(object_point[0], object_point[1], where[0], where[1]))
final_batch_data, data_raw, gaussian_mask = Data.load_image(image_data, where=where,
image_size=self.input_size)
print("begin to run ...")
# 运行
predict_output_r, pred_classes_r = self.sess.run([self.predict_output, self.pred_classes],
feed_dict={self.img_placeholder: final_batch_data})
print("end run")
# 类别
print("the class is {}({})".format(pred_classes_r[0], CategoryNames[pred_classes_r[0]]))
# 分割
segment = np.squeeze(np.asarray(np.where(predict_output_r[0] == 1, 1, 0), dtype=np.uint8))
segment = np.asarray(Image.fromarray(segment).resize((len(image_data[0]), len(image_data))))
image_mask = np.ndarray(image_data.shape)
image_mask[:, :, 0] = (1 - segment) * image_data[:, :, 0] + segment * (
opacity * mask_color[0] + (1 - opacity) * image_data[:, :, 0])
image_mask[:, :, 1] = (1 - segment) * image_data[:, :, 1] + segment * (
opacity * mask_color[1] + (1 - opacity) * image_data[:, :, 1])
image_mask[:, :, 2] = (1 - segment) * image_data[:, :, 2] + segment * (
opacity * mask_color[2] + (1 - opacity) * image_data[:, :, 2])
plt.clf() # clear image
plt.text(len(image_data[0]) // 2 - 10, -6, CategoryNames[pred_classes_r[0]], fontsize=15)
plt.imshow(image_mask.astype(np.uint8))
print("")
pass
except Exception:
print("..................")
print("...... close .....")
print("..................")
pass
pass
def run(self,
result_filename,
image_filename,
where=None,
annotation_filename=None,
ann_index=0):
# 读入图片数据
if annotation_filename:
final_batch_data, data_raw, gaussian_mask, ann_data, ann_mask = Data.load_image(
image_filename,
where=where,
annotation_filename=annotation_filename,
ann_index=ann_index,
image_size=self.input_size)
else:
final_batch_data, data_raw, gaussian_mask = Data.load_image(
image_filename,
where=where,
annotation_filename=annotation_filename,
ann_index=ann_index,
image_size=self.input_size)
# 网络
img_placeholder = tf.placeholder(dtype=tf.float32,
shape=(None, self.input_size[0],
self.input_size[1], 4))
net = PSPNet({'data': img_placeholder},
is_training=True,
num_classes=21,
last_pool_size=self.last_pool_size,
filter_number=32,
num_segment=4)
# 输出/预测
raw_output_op = net.layers["conv6_n_4"]
sigmoid_output_op = tf.sigmoid(raw_output_op)
predict_output_op = tf.argmax(sigmoid_output_op, axis=-1)
raw_output_classes = net.layers['class_attention_fc']
pred_classes = tf.cast(tf.argmax(raw_output_classes, axis=-1),
tf.int32)
# 启动Session/加载模型
sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(
allow_growth=True)))
sess.run(tf.global_variables_initializer())
Tools.restore_if_y(sess, self.log_dir)
# 运行
raw_output, sigmoid_output, predict_output_r, raw_output_classes_r, pred_classes_r = sess.run(
[
raw_output_op, sigmoid_output_op, predict_output_op,
raw_output_classes, pred_classes
],
feed_dict={img_placeholder: final_batch_data})
# 保存
print("{} {} {}".format(pred_classes_r[0],
CategoryNames[pred_classes_r[0]],
raw_output_classes_r))
print("result in {}".format(
os.path.join(self.save_dir, result_filename)))
Image.fromarray(np.asarray(np.squeeze(data_raw), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "data.png"))
output_result = np.squeeze(
np.split(np.asarray(sigmoid_output[0] * 255, dtype=np.uint8),
axis=-1,
indices_or_sections=4))
Image.fromarray(
np.squeeze(
np.asarray(predict_output_r[0] * 255 // 4,
dtype=np.uint8))).save(
os.path.join(self.save_dir,
result_filename + "pred.png"))
Image.fromarray(output_result[0]).save(
os.path.join(self.save_dir, result_filename + "pred_0.png"))
Image.fromarray(output_result[1]).save(
os.path.join(self.save_dir, result_filename + "pred_1.png"))
Image.fromarray(output_result[2]).save(
os.path.join(self.save_dir, result_filename + "pred_2.png"))
Image.fromarray(output_result[3]).save(
os.path.join(self.save_dir, result_filename + "pred_3.png"))
Image.fromarray(
np.asarray(np.squeeze(gaussian_mask * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "mask.bmp"))
if annotation_filename:
Image.fromarray(
np.asarray(np.squeeze(ann_mask * 255), dtype=np.uint8)).save(
os.path.join(self.save_dir, result_filename + "ann.bmp"))
pass
pass