Initial commit for web interface
Change-Id: I133eaf37221a050eb3c87e245b86ae54c610d446
diff --git a/person_detection/person_detection.py b/person_detection/person_detection.py
index 702f9f8..6f56a6f 100644
--- a/person_detection/person_detection.py
+++ b/person_detection/person_detection.py
@@ -13,6 +13,7 @@
from argparse import ArgumentParser, SUPPRESS
from imutils import build_montages
from openvino.inference_engine import IECore
+from base_camera import BaseCamera
def build_argparser():
@@ -40,152 +41,164 @@
return parser
-def main():
- log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
- args = build_argparser().parse_args()
- model_xml = args.model
- model_bin = os.path.splitext(model_xml)[0] + ".bin"
+class Camera(BaseCamera):
- # Read IR
- log.info("Reading IR...")
- net = IECore().read_network(model=model_xml, weights=model_bin)
+ def __init__(self, args):
+ log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+ model_xml = args.model
+ model_bin = os.path.splitext(model_xml)[0] + ".bin"
- assert len(net.inputs.keys()) == 1, "Demo supports only single input topologies"
- assert len(net.outputs) == 1, "Demo supports only single output topologies"
- input_blob = next(iter(net.inputs))
- out_blob = next(iter(net.outputs))
+ # Read IR
+ log.info("Reading IR...")
+ net = IECore().read_network(model=model_xml, weights=model_bin)
- log.info("Loading IR to the plugin...")
- exec_net = IECore().load_network(network=net, device_name=args.device, num_requests=2)
- # Read and pre-process input image
- n, c, h, w = net.inputs[input_blob].shape
- del net
- if args.input == 'cam':
- input_stream = 0
- elif args.input == 'gstreamer':
- # gst rtp sink
- input_stream = 'udpsrc port=5000 caps = " application/x-rtp, encoding-name=JPEG,payload=26" ! rtpjpegdepay ! decodebin ! videoconvert ! appsink'
- #input_stream = 'udpsrc port=5000 caps = "application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264, payload=(int)96" ! rtph264depay ! decodebin ! videoconvert ! appsink'
- else:
- input_stream = args.input
- assert os.path.isfile(args.input), "Specified input file doesn't exist"
+ assert len(net.inputs.keys()) == 1, "Demo supports only single input topologies"
+ assert len(net.outputs) == 1, "Demo supports only single output topologies"
+ self.input_blob = next(iter(net.inputs))
+ self.out_blob = next(iter(net.outputs))
- if input_stream == 'gstreamer':
- cap = cv2.VideoCapture(input_stream, cv2.CAP_GSTREAMER)
- else:
- cap = cv2.VideoCapture(input_stream)
-
- if args.labels:
- with open(args.labels, 'r') as f:
- labels_map = [x.strip() for x in f]
- else:
- labels_map = None
-
- cur_request_id = 0
- next_request_id = 1
-
- log.info("Starting inference in async mode...")
- log.info("To switch between sync and async modes press Tab button")
- log.info("To stop the demo execution press Esc button")
-
- # Async doesn't work if True
- # Request issues = Runtime Error: [REQUEST BUSY]
- is_async_mode = False
- #is_async_mode = True
- render_time = 0
- ret, frame = cap.read()
-
- frameList = []
-
- print("To close the application, press 'CTRL+C' or any key with focus on the output window")
-
- while True:
- if is_async_mode:
- ret, next_frame = cap.read()
+ log.info("Loading IR to the plugin...")
+ self.exec_net = IECore().load_network(network=net, device_name=args.device, num_requests=2)
+ # Read and pre-process input image
+ self.n, self.c, self.h, self.w = net.inputs[self.input_blob].shape
+ del net
+ if args.input == 'cam':
+ input_stream = 0
+ elif args.input == 'gstreamer':
+ # gst rtp sink
+ input_stream = 'udpsrc port=5000 caps = " application/x-rtp, encoding-name=JPEG,payload=26" ! rtpjpegdepay ! decodebin ! videoconvert ! appsink'
+ #input_stream = 'udpsrc port=5000 caps = "application/x-rtp, media=(string)video, clock-rate=(int)90000, encoding-name=(string)H264, payload=(int)96" ! rtph264depay ! decodebin ! videoconvert ! appsink'
else:
- ret, frame = cap.read()
- if not ret:
- break
- initial_w = cap.get(3)
- initial_h = cap.get(4)
+ input_stream = args.input
+ assert os.path.isfile(args.input), "Specified input file doesn't exist"
- # Main sync point:
- # in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
- # in the regular mode we start the CURRENT request and immediately wait for it's completion
- inf_start = time.time()
- if is_async_mode:
- if ret:
- in_frame = cv2.resize(next_frame, (w, h))
- in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
- in_frame = in_frame.reshape((n, c, h, w))
- exec_net.start_async(request_id=next_request_id, inputs={input_blob: in_frame})
+ if input_stream == 'gstreamer':
+ self.cap = cv2.VideoCapture(input_stream, cv2.CAP_GSTREAMER)
else:
- if ret:
- in_frame = cv2.resize(frame, (w, h))
- in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
- in_frame = in_frame.reshape((n, c, h, w))
- exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
+ self.cap = cv2.VideoCapture(input_stream)
- if exec_net.requests[cur_request_id].wait(-1) == 0:
- inf_end = time.time()
- det_time = inf_end - inf_start
+ if args.labels:
+ with open(args.labels, 'r') as f:
+ self.labels_map = [x.strip() for x in f]
+ else:
+ self.labels_map = None
- # Parse detection results of the current request
- res = exec_net.requests[cur_request_id].outputs[out_blob]
+ self.args = args
- for obj in res[0][0]:
- # Draw only objects when probability more than specified threshold
- if obj[2] > args.prob_threshold:
- xmin = int(obj[3] * initial_w)
- ymin = int(obj[4] * initial_h)
- xmax = int(obj[5] * initial_w)
- ymax = int(obj[6] * initial_h)
- class_id = int(obj[1])
- # Draw box and label\class_id
- color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 5, 255))
- cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
- det_label = labels_map[class_id] if labels_map else str(class_id)
- cv2.putText(frame, det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %', (xmin, ymin - 7),
- cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1)
- print('Object detected, class_id:', class_id, 'probability:', obj[2], 'xmin:', xmin, 'ymin:', ymin,
- 'xmax:', xmax, 'ymax:', ymax)
+ super(Camera, self).__init__()
- # Draw performance stats
- inf_time_message = "Inference time: Not applicable for async mode" if is_async_mode else \
- "Inference time: {:.3f} ms".format(det_time * 1000)
- render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
- if is_async_mode:
- async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id)
+ def __del__(self):
+ self.cap.release()
+ cv2.destroyAllWindows()
+
+ def frames(self):
+ cur_request_id = 0
+ next_request_id = 1
+
+ log.info("Starting inference in async mode...")
+ log.info("To switch between sync and async modes press Tab button")
+ log.info("To stop the demo execution press Esc button")
+
+ # Async doesn't work if True
+ # Request issues = Runtime Error: [REQUEST BUSY]
+ self.is_async_mode = False
+ #is_async_mode = True
+ render_time = 0
+ ret, frame = self.cap.read()
+
+ frameList = []
+
+ print("To close the application, press 'CTRL+C' or any key with focus on the output window")
+
+ while True:
+ if self.is_async_mode:
+ ret, next_frame = self.cap.read()
else:
- async_mode_message = "Async mode is off. Processing request {}".format(cur_request_id)
+ ret, frame = self.cap.read()
+ if not ret:
+ break
+ initial_w = self.cap.get(3)
+ initial_h = self.cap.get(4)
- cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
- cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
- cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
- (10, 10, 200), 1)
+ # Main sync point:
+ # in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
+ # in the regular mode we start the CURRENT request and immediately wait for it's completion
+ inf_start = time.time()
+ if self.is_async_mode:
+ if ret:
+ in_frame = cv2.resize(next_frame, (self.w, self.h))
+ in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
+ in_frame = in_frame.reshape((self.n, self.c, self.h, self.w))
+ self.exec_net.start_async(request_id=next_request_id, inputs={self.input_blob: in_frame})
+ else:
+ if ret:
+ in_frame = cv2.resize(frame, (self.w, self.h))
+ in_frame = in_frame.transpose((2, 0, 1)) # Change data layout from HWC to CHW
+ in_frame = in_frame.reshape((self.n, self.c, self.h, self.w))
+ self.exec_net.start_async(request_id=cur_request_id, inputs={self.input_blob: in_frame})
- render_start = time.time()
+ if self.exec_net.requests[cur_request_id].wait(-1) == 0:
+ inf_end = time.time()
+ det_time = inf_end - inf_start
- if not args.ns:
- if ret:
- cv2.imshow("Detection results", frame)
- render_end = time.time()
- render_time = render_end - render_start
+ # Parse detection results of the current request
+ res = self.exec_net.requests[cur_request_id].outputs[self.out_blob]
- if is_async_mode:
- cur_request_id, next_request_id = next_request_id, cur_request_id
+ for obj in res[0][0]:
+ # Draw only objects when probability more than specified threshold
+ if obj[2] > self.args.prob_threshold:
+ xmin = int(obj[3] * initial_w)
+ ymin = int(obj[4] * initial_h)
+ xmax = int(obj[5] * initial_w)
+ ymax = int(obj[6] * initial_h)
+ class_id = int(obj[1])
+ # Draw box and label\class_id
+ color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 5, 255))
+ cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
+ det_label = self.labels_map[class_id] if self.labels_map else str(class_id)
+ cv2.putText(frame, det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %', (xmin, ymin - 7),
+ cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1)
+ print('Object detected, class_id:', class_id, 'probability:', obj[2], 'xmin:', xmin, 'ymin:', ymin,
+ 'xmax:', xmax, 'ymax:', ymax)
- frame = next_frame
- key = cv2.waitKey(1)
- if key == 27:
- break
- if 9 == key:
- is_async_mode = not is_async_mode
- log.info("Switched to {} mode".format("async" if is_async_mode else "sync"))
+ # Draw performance stats
+ inf_time_message = "Inference time: Not applicable for async mode" if self.is_async_mode else \
+ "Inference time: {:.3f} ms".format(det_time * 1000)
+ render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
+ if self.is_async_mode:
+ async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id)
+ else:
+ async_mode_message = "Async mode is off. Processing request {}".format(cur_request_id)
- cap.release()
- cv2.destroyAllWindows()
+ cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
+ cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
+ cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
+ (10, 10, 200), 1)
+
+ render_start = time.time()
+
+ yield cv2.imencode('.jpg', frame)[1].tobytes()
+
+ if not self.args.ns:
+ if ret:
+ cv2.imshow("Detection results", frame)
+ render_end = time.time()
+ render_time = render_end - render_start
+
+ if self.is_async_mode:
+ cur_request_id, next_request_id = next_request_id, cur_request_id
+
+ frame = next_frame
+ key = cv2.waitKey(1)
+ if key == 27:
+ break
+ if 9 == key:
+ self.is_async_mode = not self.is_async_mode
+ log.info("Switched to {} mode".format("async" if self.is_async_mode else "sync"))
if __name__ == '__main__':
- sys.exit(main() or 0)
+ args = build_argparser().parse_args()
+ camera = Camera(args)
+ camera.frames()
+ del camera