def main():
video_capture = WebcamVideoStream(src=0, width=480, height=360).start()
fps = FPS().start()
detection_graph = model_load_into_memory()
thread1 = ServerHandlerPacket("Thread-1-ServerHandlerPacket")
thread1.daemon = True
thread1.start()
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
while True:
# Camera detection loop
frame = video_capture.read()
cv2.imshow('Entrada', frame)
t = time.time()
output = detect_objects(frame, sess, detection_graph)
cv2.imshow('Video', output)
fps.update()
print('[INFO] elapsed time: {:.2f}'.format(time.time() - t))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
video_capture.stop()
fps.stop()
print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed()))
print('[INFO] approx. FPS: {:.2f}'.format(fps.fps()))
cv2.destroyAllWindows()
def runVideo(cap):
Frame.frame_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH)
Frame.frame_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT)
first_go = True
frame = None
current_frame = None
previous_frame = None
while (True):
if first_go != True:
previous_frame = Frame(current_frame.getFrame())
ret, frame = cap.read()
if ret == False:
break
else:
current_frame = Frame(frame)
if first_go != True:
difference_frame = current_frame.getDifferenceFrame(previous_frame)
thresholded_frame = difference_frame.getBinary(threshold=100)
dilated_frame = thresholded_frame.getDilated(iterations=10)
valid_contours = dilated_frame.findObjects(
minContourZone=settings.MIN_COUNTOUR_ZONE)
Tracker.registerNewObjects(valid_contours, current_frame)
# set which frame to display for user
ready_frame = current_frame
ready_frame.addBoundingBoxesFromContours(Tracker)
st.write("test")
ready_frame.putText("Threads: " + str(threading.active_count()),
(7, 20))
ready_frame.putText(
"Object Bufor size: " + str(len(Tracker.objectsToClassify)),
(7, 50))
ready_frame.putText("FPS: " + FPS.tick(), (7, 80))
ready_frame.putText(
"Cars passed: " + str(len(Tracker.lostObjects)), (7, 110))
ready_frame.putText("Test var: " + str(12), (7, 140))
ready_frame.show()
else:
first_go = False
current_frame.show()
if cv2.waitKey(1) & 0xFF == ord('q'):
logger('cars found: ' + str(Tracker.lostObjects), settings.LOG)
break
cap.release()
cv2.destroyAllWindows()
stopThreads()
def worker(input_q, output_q):
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
fps = FPS().start()
while True:
fps.update()
frame = input_q.get()
output_q.put(detect_objects(frame, sess, detection_graph))
fps.stop()
sess.close()
def worker(input_q, output_q, net, min_confidence):
fps = FPS().start()
while True:
fps.update()
frm = input_q.get()
frm = detect_objects(frm, net, min_confidence)
frm = detect_face_vj(frm)
output_q.put(frm)
fps.stop()
def worker(input_q, output_q):
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
fps = FPS().start()
initial_frame = input_q.get()
boxes, classes, scores = detect_objects(initial_frame, sess,
detection_graph)
people_tracker.make_initial_analysis(boxes, scores)
output_q.put(plot_objects(initial_frame, boxes, classes, scores))
assumed_fps = 15
record_counter_at = 0
record_counter_limit = assumed_fps * RECORD_DATA_INTERVAL_TIME
while True:
fps.update()
frame = input_q.get()
boxes, classes, scores = detect_objects(frame, sess, detection_graph)
_ = people_tracker.update_person_tracker(boxes, scores)
record_counter_at += 1
if record_counter_at >= record_counter_limit:
people_tracker.save_recorded_data_in_file()
record_counter_at = 0
people_tracker.remove_junk_data()
output_q.put(plot_objects(frame, boxes, classes, scores))
fps.stop()
sess.close()
def worker(input_q, output_q):
# Load a (frozen) Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
fps = FPS().start()
while True:
fps.update()
frame = input_q.get()
output_q.put(detect_objects(frame, sess, detection_graph))
fps.stop()
sess.close()
if net.empty():
exit(1)
pool = Pool(args.num_workers, worker,
(input_q, output_q, net, args.min_confidence))
video_capture = WebcamVideoStream(src=args.video_source,
width=args.width,
height=args.height).start()
# Define the codec and create VideoWriter object
fourcc = cv.VideoWriter_fourcc(*args.codec)
out = cv.VideoWriter(args.save, fourcc, args.fps,
(args.width, args.height))
fps = FPS().start()
while True: # fps._numFrames < 120
frame = video_capture.read()
input_q.put(frame)
t = time.time()
output_frame = output_q.get()
out.write(output_frame)
cv.imshow('Video', output_frame)
fps.update()
print('[INFO] elapsed time: {:.2f}'.format(time.time() - t))
if cv.waitKey(1) & 0xFF == ord('q'):
break
fps.stop()
print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed()))
print('[INFO] approx. FPS: {:.2f}'.format(fps.fps()))
# Get a reference to webcam #0 (the default one). This could be made a command line option.
video_capture = WebcamVideoStream(src=0,
width=settings['width'],
height=settings['height']).start()
# Setup some rendering related things
canvas = None
quickdraw = QuickDraw()
sketch_images = {}
line_color = (156, 156, 156)
sprites = []
last_added_sprite = time.time()
# Track fps
fps = FPS().start()
# Loop until the user hits 'q' to quit
while True:
# Grab a single frame of video
frame = video_capture.read()
# Pick the background to draw on
if settings['video']:
canvas = frame.copy()
else:
canvas = np.zeros((settings['height'], settings['width'], 3),
np.uint8)
canvas[:, :, :] = (255, 255, 255)
logger.debug('done setting up canvas')
def main():
# Load the AdaIN model
ada_in = AdaINference(args.checkpoint, args.vgg_path, device=args.device)
# Load a panel to control style settings
style_window = StyleWindow(args.style_path, args.style_size, args.scale, args.alpha, args.interpolate)
# Start the webcam stream
cap = WebcamVideoStream(args.video_source, args.width, args.height).start()
_, frame = cap.read()
# Grab a sample frame to calculate frame size
frame_resize = cv2.resize(frame, None, fx=args.scale, fy=args.scale)
img_shape = frame_resize.shape
# Setup video out writer
if args.video_out is not None:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
if args.concat:
out_shape = (img_shape[1]+img_shape[0],img_shape[0]) # Make room for the style img
else:
out_shape = (img_shape[1],img_shape[0])
print('Video Out Shape:', out_shape)
video_writer = cv2.VideoWriter(args.video_out, fourcc, args.fps, out_shape)
fps = FPS().start() # Track FPS processing speed
keep_colors = args.keep_colors
count = 0
while(True):
ret, frame = cap.read()
if ret is True:
frame_resize = cv2.resize(frame, None, fx=style_window.scale, fy=style_window.scale)
if args.noise: # Generate textures from noise instead of images
frame_resize = np.random.randint(0, 256, frame_resize.shape, np.uint8)
frame_resize = gaussian_filter(frame_resize, sigma=0.5)
count += 1
print("Frame:",count,"Orig shape:",frame.shape,"New shape",frame_resize.shape)
content_rgb = cv2.cvtColor(frame_resize, cv2.COLOR_BGR2RGB) # OpenCV uses BGR, we need RGB
if args.random > 0 and count % args.random == 0:
style_window.set_style(random=True, style_idx=0)
if keep_colors:
style_rgb = preserve_colors_np(style_window.style_rgbs[0], content_rgb)
else:
style_rgb = style_window.style_rgbs[0]
if args.interpolate is False:
# Run the frame through the style network
stylized_rgb = ada_in.predict(content_rgb, style_rgb, style_window.alpha)
else:
interp_weights = [style_window.interp_weight, 1 - style_window.interp_weight]
stylized_rgb = ada_in.predict_interpolate(content_rgb,
style_window.style_rgbs,
interp_weights,
style_window.alpha)
# Stitch the style + stylized output together, but only if there's one style image
if args.concat and args.interpolate is False:
# Resize style img to same height as frame
style_rgb_resized = cv2.resize(style_rgb, (stylized_rgb.shape[0], stylized_rgb.shape[0]))
stylized_rgb = np.hstack([style_rgb_resized, stylized_rgb])
stylized_bgr = cv2.cvtColor(stylized_rgb, cv2.COLOR_RGB2BGR)
if args.video_out is not None:
stylized_bgr = cv2.resize(stylized_bgr, out_shape) # Make sure frame matches video size
video_writer.write(stylized_bgr)
cv2.imshow('AdaIN Style', stylized_bgr)
fps.update()
key = cv2.waitKey(10)
if key & 0xFF == ord('r'): # Load new random style
style_window.set_style(random=True, style_idx=0)
if args.interpolate: # Load a a second style if interpolating
style_window.set_style(random=True, style_idx=1, window='style2')
elif key & 0xFF == ord('c'):
keep_colors = not keep_colors
print("Switching to keep_colors",keep_colors)
elif key & 0xFF == ord('q'): # Quit
break
else:
break
fps.stop()
print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed()))
print('[INFO] approx. FPS: {:.2f}'.format(fps.fps()))
cap.stop()
if args.video_out is not None:
video_writer.release()
cv2.destroyAllWindows()
persist_queue = Queue()
persistence_worker = Thread(target=worker_persist,
args=(persist_queue, ),
daemon=True)
persistence_worker.start()
stream = VideoStream(0).start()
time.sleep(2)
sort_tracker = Sort(max_age=20, min_hits=1)
if __name__ == "__main__":
dets = np.array([])
labels = np.array([])
probs_max = np.array([])
faces = np.array([])
fps = FPS().start()
while True:
ret, frame = stream.read()
if not ret:
continue
frame = cv2.resize(frame, (1280, 720))
if fps._numFrames % SKIP_FRAME == 0:
rects = detector(frame, 0)
dets = np.array([get_pos_from_rect(rect) for rect in rects])
labels = np.empty(len(rects))
probs_max = np.empty(len(rects))
faces = np.array([get_face_from_frame(det, frame) for det in dets])
frame_processed = preprocess(frame)[..., ::-1]
if len(rects) > 0:
embeddings = []
for i, rect in enumerate(rects):
def main():
# Load the WCT model
wct_model = WCT(checkpoints=args.checkpoints,
relu_targets=args.relu_targets,
vgg_path=args.vgg_path,
device=args.device)
# Load a panel to control style settings
style_window = StyleWindow(args.style_path, args.style_size,
args.crop_size, args.scale, args.alpha,
args.interpolate)
# Start the webcam stream
cap = WebcamVideoStream(args.video_source, args.width, args.height).start()
_, frame = cap.read()
# Grab a sample frame to calculate frame size
frame_resize = cv2.resize(frame, None, fx=args.scale, fy=args.scale)
img_shape = frame_resize.shape
# Setup video out writer
if args.video_out is not None:
fourcc = cv2.VideoWriter_fourcc(*'XVID')
if args.concat:
out_shape = (img_shape[1] + img_shape[0], img_shape[0]
) # Make room for the style img
else:
out_shape = (img_shape[1], img_shape[0])
print('Video Out Shape:', out_shape)
video_writer = cv2.VideoWriter(args.video_out, fourcc, args.fps,
out_shape)
fps = FPS().start() # Track FPS processing speed
keep_colors = args.keep_colors
count = 0
while (True):
if args.max_frames > 0 and count > args.max_frames:
break
ret, frame = cap.read()
if ret is True:
frame_resize = cv2.resize(frame,
None,
fx=style_window.scale,
fy=style_window.scale)
if args.noise: # Generate textures from noise instead of images
frame_resize = np.random.randint(0, 256, frame_resize.shape,
np.uint8)
count += 1
print("Frame:", count, "Orig shape:", frame.shape, "New shape",
frame_resize.shape)
content_rgb = cv2.cvtColor(
frame_resize,
cv2.COLOR_BGR2RGB) # OpenCV uses BGR, we need RGB
if args.random > 0 and count % args.random == 0:
style_window.set_style(random=True, style_idx=0)
if keep_colors:
style_rgb = preserve_colors_np(style_window.style_rgbs[0],
content_rgb)
else:
style_rgb = style_window.style_rgbs[0]
# For best results style img should be comparable size to content
# style_rgb = resize_to(style_rgb, min(content_rgb.shape[0], content_rgb.shape[1]))
if args.interpolate is False:
# Run the frame through the style network
stylized_rgb = wct_model.predict(content_rgb, style_rgb,
style_window.alpha)
if args.passes > 1:
for i in range(args.passes - 1):
stylized_rgb = wct_model.predict(
stylized_rgb, style_rgb, style_window.alpha)
# stylized_rgb = wct_model.predict_np(content_rgb, style_rgb, style_window.alpha) # Numpy version
# else: ## TODO Implement interpolation
# interp_weights = [style_window.interp_weight, 1 - style_window.interp_weight]
# stylized_rgb = wct_model.predict_interpolate(content_rgb,
# style_window.style_rgbs,
# interp_weights,
# style_window.alpha)
# Stitch the style + stylized output together, but only if there's one style image
if args.concat and args.interpolate is False:
# Resize style img to same height as frame
style_rgb_resized = cv2.resize(
style_rgb, (stylized_rgb.shape[0], stylized_rgb.shape[0]))
stylized_rgb = np.hstack([style_rgb_resized, stylized_rgb])
stylized_bgr = cv2.cvtColor(stylized_rgb, cv2.COLOR_RGB2BGR)
if args.video_out is not None:
stylized_bgr = cv2.resize(
stylized_bgr,
out_shape) # Make sure frame matches video size
video_writer.write(stylized_bgr)
cv2.imshow('WCT Universal Style Transfer', stylized_bgr)
fps.update()
key = cv2.waitKey(10)
if key & 0xFF == ord('r'): # Load new random style
style_window.set_style(random=True, style_idx=0)
if args.interpolate: # Load a a second style if interpolating
style_window.set_style(random=True,
style_idx=1,
window='style2')
elif key & 0xFF == ord('c'):
keep_colors = not keep_colors
print('Switching to keep_colors', keep_colors)
elif key & 0xFF == ord('s'):
out_f = "{}.png".format(time.time())
save_img(out_f, stylized_rgb)
print('Saved image to', out_f)
elif key & 0xFF == ord('q'): # Quit
break
else:
break
fps.stop()
print('[INFO] elapsed time (total): {:.2f}'.format(fps.elapsed()))
print('[INFO] approx. FPS: {:.2f}'.format(fps.fps()))
cap.stop()
if args.video_out is not None:
video_writer.release()
cv2.destroyAllWindows()
def main(args):
"""
Main programm loop.
Parameters
----------
args : command line arguments parsed by parse_arguments
"""
# Setup PoseEstimator, pipeline, windows with sliders for PoseEstimator
# options and load video if running on local video file
camera = args["video"] is None
if args["model"] not in model_list:
raise ValueError("Unknown model '{}'".format(args["model"]))
model_config = model_list[args["model"]]
pose_estimator = get_poseestimator(model_config, **args)
with dai.Device(
create_pipeline(model_config, camera, passthrough=True,
**args)) as device:
device.startPipeline()
if camera:
preview_queue = device.getOutputQueue("preview",
maxSize=4,
blocking=False)
else:
pose_in_queue = device.getInputQueue("pose_in")
pose_queue = device.getOutputQueue("pose")
passthrough_queue = device.getOutputQueue("passthrough")
# Load video if given in command line and set the variables used below
# to control FPS and looping of the video
if not camera:
if not os.path.exists(args["video"]):
raise ValueError("Video '{}' does not exist.".format(
args["video"]))
print("Loading video", args["video"])
video = cv2.VideoCapture(args["video"])
frame_interval = 1 / video.get(cv2.CAP_PROP_FPS)
last_frame_time = 0
frame_id = 0
else:
print("Running on OAK camera preview stream")
# Create windows for the original video and the video of frames from
# the NN passthrough. The window for the original video gets all the
# option sliders to change pose estimator config
video_window_name = "Original Video"
passthrough_window_name = "Processed Video"
video_window = SliderWindow(video_window_name)
cv2.namedWindow(passthrough_window_name)
video_window.add_poseestimator_options(pose_estimator, args)
# Start main loop
frame = None
keypoints = None
fps = FPS("Video", "NN", interval=0.1)
timer = Timer("inference", "decode")
while True:
# Check for and handle slider changes
slider_changes = video_window.get_changes()
for option_name, value in slider_changes.items():
pose_estimator.set_option(option_name, value)
fps.start_frame()
# Get next video frame (and submit for processing if local video)
if camera:
frame = preview_queue.get().getCvFrame()
fps.count("Video")
else:
frame_time = time.perf_counter()
# Only grab next frame from file at certain intervals to
# roughly preserve its original FPS
if frame_time - last_frame_time > frame_interval:
if video.grab():
__, frame = video.retrieve()
fps.count("Video")
last_frame_time = frame_time
# Create DepthAI ImgFrame object to pass to the
# camera
input_frame = pose_estimator.get_input_frame(frame)
frame_nn = dai.ImgFrame()
frame_nn.setSequenceNum(frame_id)
frame_nn.setWidth(input_frame.shape[2])
frame_nn.setHeight(input_frame.shape[1])
frame_nn.setType(dai.RawImgFrame.Type.BGR888p)
frame_nn.setFrame(input_frame)
pose_in_queue.send(frame_nn)
frame_id += 1
else:
frame_id = 0
video.set(cv2.CAP_PROP_POS_FRAMES, frame_id)
# Process pose data whenever a new packet arrives
if pose_queue.has():
raw_output = pose_queue.get()
timer.start_timer("decode")
keypoints = pose_estimator.get_pose_data(raw_output)
timer.stop_timer("decode")
fps.count("NN")
# When keypoints are available we should also have a
# passthrough frame to process and display. Make sure it is
# availabe to avoid suprises.
if passthrough_queue.has():
passthrough = passthrough_queue.get()
timer.frame_time("inference", passthrough)
passthrough_frame = passthrough.getCvFrame()
passthrough_frame = pose_estimator.get_original_frame(
passthrough_frame)
pose_estimator.draw_results(keypoints, passthrough_frame)
cv2.imshow(passthrough_window_name, passthrough_frame)
# Annotate current video frame with keypoints and FPS
if keypoints is not None:
pose_estimator.draw_results(keypoints, frame)
fps.update()
fps.display(frame)
cv2.imshow(video_window_name, frame)
if cv2.waitKey(1) == ord("q"):
break
fps.print_totals()
timer.print_times()
cv2.destroyAllWindows()
args = parser.parse_args()
logger = multiprocessing.log_to_stderr()
logger.setLevel(multiprocessing.SUBDEBUG)
input_q = Queue(maxsize=args.queue_size)
output_q = Queue(maxsize=args.queue_size)
process = Process(target=worker, args=((input_q, output_q)))
process.daemon = True
pool = Pool(args.num_workers, worker, (input_q, output_q))
video_capture = WebcamVideoStream(src=args.video_source,
width=args.width,
height=args.height).start()
fps = FPS().start()
while True: # fps._numFrames < 120
frame = video_capture.read()
input_q.put(frame)
t = time.time()
cv2.imshow('Video', output_q.get())
fps.update()
print('[INFO] elapsed time: {:.2f}'.format(time.time() - t))
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# 读取网络模型
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])
# 初始化
print("[INFO] starting video stream...")
vs = cv2.VideoCapture(args["video"])
writer = None
# 一会要追踪多个目标
trackers = []
labels = []
# 计算FPS
fps = FPS().start()
while True:
# 读取一帧
(grabbed, frame) = vs.read()
# 是否是最后了
if frame is None:
break
# 预处理操作
(h, w) = frame.shape[:2]
width=600
r = width / float(w)
dim = (width, int(h * r))
frame = cv2.resize(frame, dim, interpolation=cv2.INTER_AREA)
output_image,
root_output,
threshold=distance,
last_frames=args.last_frames,
tracking=args.dist_track) # rootnet image
if args.mask or args.mask_track:
hpe_output = hpEstimator.predict(
bboxes,
image) # [[x1, y1, x2, y2], ...], [[joints], ...], [pid, ...]]
if args.skeleton:
output_image = draw(hpe_output[1], image) # skeleton image
output_image = detect_mask(classifier,
hpe_output,
image,
output_image,
conf_thresh=args.mask_thresh,
eyes_thresh=args.eyes_thresh,
max_len=args.len_buffer,
tracking=args.mask_track)
fps = 1. / (time.time() - start)
output_image = FPS(output_image, fps)
cv2.waitKey(1)
cv2.imshow('COVID-monitor', output_image)
if args.saveName is not None:
videoWriter.write(output_image)
print('\rframerate: %f fps' % fps, end='')