def pred_by_drawing(img_path, save_path):
img = cv2.imread(img_path)
*_, img_name = os.path.split(img_path)
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 drawBoundingBox(self, img, rclasses, rscores, rbboxes):
visualization.bboxes_draw_on_img(img,
rclasses,
rscores,
np.array(rbboxes),
visualization.colors_plasma,
cropper=self.cropper)
return img
def Catch_Video(self, window_name='Detertor'):
cv2.namedWindow(window_name)
cap = cv2.VideoCapture(self.camera_index)
while cap.isOpened():
catch, frame = cap.read() # 读取每一帧图片
if not catch:
raise Exception('Check if the camera if on.')
break
rclasses, rscores, rbboxes = process_image(frame) # 这里传入图片
labeled_img = visualization.bboxes_draw_on_img(
frame, rclasses, rscores, rbboxes, visualization.colors_plasma)
cv2.imshow(window_name, labeled_img)
c = cv2.waitKey(10)
if c & 0xFF == ord('q'):
# 按q退出
break
if cv2.getWindowProperty(window_name, cv2.WND_PROP_AUTOSIZE) < 1:
# 点x退出
break
# 释放摄像头
cap.release()
cv2.destroyAllWindows()
def CatchUsbVideo(window_name, camera_idx):
# cv2.namedWindow(window_name)
cap = cv2.VidgiteoCapture(camera_idx)
while cap.isOpened():
ok, img = cap.read()
if not ok:
break
# img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# img = mpimg.imread(frame)
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)
cv2.imshow(window_name, img)
c = cv2.waitKey(10)
if c & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
def detect_video(video, all_classes, ssd):
"""Use ssd to detect video.
# Argument:
video: video file.
all_classes: all classes name.
"""
video_path = os.path.join("videos", "test", video)
if (os.path.exists(video_path) and video != ''):
camera = cv2.VideoCapture(video_path)
else:
camera = cv2.VideoCapture(0)
video = 'your_camera.mp4'
res, frame = camera.read()
if not res:
print("file open failed and camera can not open")
cv2.namedWindow("detection", cv2.WINDOW_AUTOSIZE)
# Prepare for saving the detected video
sz = (int(camera.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(camera.get(cv2.CAP_PROP_FRAME_HEIGHT)))
fourcc = cv2.VideoWriter_fourcc(*'mpeg')
vout = cv2.VideoWriter()
vout.open(os.path.join("videos", "res", video), fourcc, 20, sz, True)
while True:
res, frame = camera.read()
if not res:
break
rclasses, rscores, rbboxes = ssd._process_image(frame)
image = visualization.bboxes_draw_on_img(frame, rclasses, rscores,
rbboxes,
visualization.colors_plasma,
all_classes)
cv2.imshow("detection", image)
# Save the video frame by frame
vout.write(image)
if cv2.waitKey(110) & 0xff == 27: #press ESC to quit
break
vout.release()
camera.release()
def Catch_Video(self, window_name='Detertor'):
cap = cv2.VideoCapture(self.camera_index)
if isinstance(self.camera_index, str):
flag = True
else:
flag = False
if not cap.isOpened():
raise Exception('Check if the camera is on.')
while cap.isOpened():
catch, frame = cap.read() # 读取每一帧图片
if not catch:
raise Exception('Check if the camera is on.')
break
rclasses, rscores, rbboxes = process_image(frame) # 这里传入图片
labeled_img = visualization.bboxes_draw_on_img(
frame, rclasses, rscores, rbboxes, visualization.colors_plasma)
if flag:
sleep(0.1)
cv2.imshow(window_name, labeled_img)
if cv2.getWindowProperty(window_name, cv2.WND_PROP_AUTOSIZE) < 1:
# 点x退出
break
# 释放摄像头
cap.release()
cv2.destroyAllWindows()
rlocalisations,
ssd_anchors,
select_threshold=select_threshold,
img_shape=net_shape,
num_classes=2,
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 = '../ImageSet/'
image_names = sorted(os.listdir(path))
for it in image_names:
img = mpimg.imread(path + it)
rclasses, rscores, rbboxes = process_image(img)
visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes,
visualization.colors_tableau, it)
# visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
def inference(input=0,inputType=1):
slim = tf.contrib.slim
sys.path.append('../')
from nets import ssd_vgg_300, ssd_common, np_methods
from preprocessing import ssd_vgg_preprocessing
from notebooks import visualization
# TensorFlow session: grow memory when needed. TF, DO NOT USE ALL MY GPU MEMORY!!!
gpu_options = tf.GPUOptions(allow_growth=True)
config = tf.ConfigProto(log_device_placement=False, gpu_options=gpu_options)
isess = tf.InteractiveSession(config=config)
# Input placeholder.
net_shape = (300, 300)
data_format = 'NHWC'
img_input = tf.placeholder(tf.uint8, shape=(None, None, 3))
# Evaluation pre-processing: resize to SSD net shape.
image_pre, labels_pre, bboxes_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, 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, localisations, _, _ = ssd_net.net(image_4d, is_training=False, reuse=reuse)
# Restore SSD model.
ckpt_filename = '../checkpoints/ssd_300_vgg.ckpt'
# ckpt_filename = '../checkpoints/VGG_VOC0712_SSD_300x300_ft_iter_120000.ckpt'
isess.run(tf.global_variables_initializer())
saver = tf.train.Saver()
saver.restore(isess, ckpt_filename)
# SSD default anchor boxes.
ssd_anchors = ssd_net.anchors(net_shape)
# Main image processing routine.
def process_image(img, select_threshold=0.5, nms_threshold=.45, net_shape=(300, 300)):
# Run SSD network.
rimg, rpredictions, rlocalisations, rbbox_img = isess.run([image_4d, predictions, localisations, bbox_img],
feed_dict={img_input: img})
# Get classes and bboxes from the net outputs.
rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select(
rpredictions, rlocalisations, ssd_anchors,
select_threshold=select_threshold, 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_threshold)
# Resize bboxes to original image shape. Note: useless for Resize.WARP!
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
return rclasses, rscores, rbboxes
# input is a image
inputType = int(inputType)
if inputType is 1:
if input == 0:
print("At least indicate 1 input video")
exit(-1)
# Test on some demo image and visualize output.
img = mpimg.imread(input)
rclasses, rscores, rbboxes = process_image(img)
# Find the name of the category num
print(list(map(lambda i:"{}:{}".format(i,category[i]),list(rclasses))))
rclasses = np.array(list(map(lambda i:"{}:{}".format(i,category[i]),list(rclasses))))
# visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
# plot the image directly
visualization.plt_bboxes(img, rclasses, rscores, rbboxes)
elif inputType == 2:
# input is the video
# plot the boxes into the image
cap = cv2.VideoCapture(input)
fps = cap.get(cv2.CAP_PROP_FPS)
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
fourcc = cap.get(cv2.CAP_PROP_FOURCC)
#fourcc = cv2.CAP_PROP_FOURCC(*'CVID')
print('fps=%d,size=%r,fourcc=%r'%(fps,size,fourcc))
delay=10/int(fps)
print(delay)
if delay <= 1:
delay = 1
while (cap.isOpened()):
ret, frame = cap.read()
print(ret)
if ret == True:
image = frame
# the array based representation of the image will be used later in order to prepare the
# result image with boxes and labels on it.
image_np = image
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
# Actual detection.
rclasses, rscores, rbboxes = process_image(image_np)
#print(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
rclasses = np.array(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
# Visualization of the results of a detection.
visualization.bboxes_draw_on_img(image_np, rclasses, rscores, rbboxes)
cv2.imshow('frame', image_np)
#cv2.waitKey(np.uint(delay))
if cv2.waitKey(delay) & 0xFF == ord('q'):
break
print('Ongoing...')
else:
break
cap.release()
cv2.destroyAllWindows()
elif inputType ==3:
print("save video")
if input == 0:
print("At least indicate 1 input video")
exit(-1)
def save_image(image_np):
rclasses, rscores, rbboxes = process_image(image_np)
# print(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
rclasses = np.array(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
visualization.bboxes_draw_on_img(image_np, rclasses, rscores, rbboxes)
return image_np
from moviepy.editor import VideoFileClip
cap = cv2.VideoCapture(input)
fps = cap.get(cv2.CAP_PROP_FPS)
cap.release()
cv2.destroyAllWindows()
video = VideoFileClip(input)
result = video.fl_image(save_image)
output = os.path.join("./videos/output_{}".format(input.split("/")[-1]))
result.write_videofile(output, fps=fps)
else:
cap = cv2.VideoCapture(0)
while (True):
# Capture frame-by-frame
ret, frame = cap.read()
#cv2.imshow('frame', frame)
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(frame, axis=0)
# Actual detection.
rclasses, rscores, rbboxes = process_image(frame)
# print(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
rclasses = np.array(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
# Visualization of the results of a detection.
visualization.bboxes_draw_on_img(frame, rclasses, rscores, rbboxes)
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
def save_image(image_np):
rclasses, rscores, rbboxes = process_image(image_np)
# print(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
rclasses = np.array(list(map(lambda i: "{}:{}".format(i, category[i]), list(rclasses))))
visualization.bboxes_draw_on_img(image_np, rclasses, rscores, rbboxes)
return image_np
# Get classes and bboxes from the net outputs.
rclasses, rscores, rbboxes = np_methods.ssd_bboxes_select( rpredictions, rlocalisations, ssd_anchors, select_threshold=select_threshold, 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_threshold)
# Resize bboxes to original image shape. Note: useless for Resize.WARP!
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
return rclasses, rscores, rbboxes
img = mpimg.imread('dog.jpg')
import time
start = time.time()
rclasses, rscores, rbboxes = process_image(img)
print rclasses,rscores,rbboxes
consume_time = (time.time() - start) * 1000
print consume_time
visualization.bboxes_draw_on_img(img, rclasses, rscores, rbboxes, visualization.colors_plasma)
visualization.plt_bboxes(img, rclasses, rscores, 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)
rbboxes = np_methods.bboxes_resize(rbbox_img, rbboxes)
return rclasses, rscores, rbboxes
if __name__ == "__main__":
import matplotlib.pyplot as plt
image_path = './a.jpg' # 图片路径
img = mpimg.imread(image_path)
rclasses, rscores, rbboxes = process_image(img) # 这里传入图片
labeled_img = visualization.bboxes_draw_on_img(
img, rclasses, rscores, rbboxes, visualization.colors_plasma) # 返回标注图片
plt.imshow(labeled_img)
plt.show()
# visualization.plt_bboxes(img, rclasses, rscores, rbboxes) # 展示（plt）标注图片
ret, frame = cap.read()
if ret == True:
image = frame
#image_np = image
#cv2.imshow('frame', image_np)
# 376 1344
# print("frame.shape[0] frame.shape[1]",image_np.shape[0],image_np.shape[1])
image1 = image[:, :672] # 左
image2 = image[:, 672:] # 右
rclasses1, rscores1, rbboxes1 = process_image(image1)
rclasses2, rscores2, rbboxes2 = process_image(image2)
visualization.bboxes_draw_on_img(image1, rclasses1, rscores1, rbboxes1)
visualization.bboxes_draw_on_img(image2, rclasses2, rscores2, rbboxes2)
cv2.imshow('image1', image1)
cv2.imshow('image2', image2)
cv2.waitKey(np.uint(delay))
else:
break
cap.release()
cv2.destroyAllWindows()
"""
############################################
class Detector(object):
