class ProcImg():
def __init__(self, stream):
self.stream = stream
self.numThread = cv2.getNumberOfCPUs()
#self.numThread = 1
self.workerPool = ThreadPool(processes = self.numThread)
self.pendingWorker = deque()
self.latency = StatValue()
self.frameInterval = StatValue()
self.lastFrameTime = clock()
self.outFrames = deque(maxlen = self.numThread)
self.faces = []
def isEmpty(self):
return(len(self.outFrames) == 0)
def getFrame(self):
return self.outFrames.popleft()
def draw(self, rects, frame):
color = (0, 0, 255)# Rect color selection
for (x,y,w,h) in rects:
pt1 = (int(x), int(y))
pt2 = (int((x+w)), int(y + h))
cv2.rectangle(frame, pt1, pt2, color, 1) # Draws the Rect
#return hits
def threadedProcess(self):
rects = []
if len(self.pendingWorker) > 0 and self.pendingWorker[0].ready():
task = self.pendingWorker.popleft()
frame, curTime = task.get()
self.latency.update(clock() - curTime)
draw_str(frame, (20, config.VIDEO_WIDTH -20), "Latency: %.1f ms" % (self.latency.value*1000))
draw_str(frame, (20, config.VIDEO_WIDTH - 35), "FPS: %d" % (1/self.frameInterval.value))
#print("Latency %lf" % (self.latency.value*1000))
#print("FPS: %d" % (1/self.frameInterval.value))
self.outFrames.append(frame)
#cv2.imshow('Processed Video', frame)
#cv2.waitKey(1)
if len(self.pendingWorker) < self.numThread:
frame = self.stream.read()
t = clock()
self.frameInterval.update(t - self.lastFrameTime)
self.lastFrameTime = t
task = self.workerPool.apply_async(process, (copy.copy(frame), t))
self.pendingWorker.append(task)
def stop(self):
workerPool.terminate()
pendingWorker.clear()
class ProcImg():
def __init__(self, stream):
self.stream = stream
self.numThread = cv2.getNumberOfCPUs()
self.numThread = 5
self.workerPool = ThreadPool(processes=self.numThread)
self.pendingWorker = deque()
self.latency = StatValue()
self.frameInterval = StatValue()
self.lastFrameTime = clock()
self.outFrames = deque(maxlen=self.numThread)
self.faces = []
def isEmpty(self):
return (len(self.outFrames) == 0)
def getFrame(self):
return self.outFrames.popleft()
def draw(self, rects, frame):
color = (0, 0, 255) # Rect color selection
for (x, y, w, h) in rects:
pt1 = (int(x), int(y))
pt2 = (int((x + w)), int(y + h))
cv2.rectangle(frame, pt1, pt2, color, 1) # Draws the Rect
#return hits
def threadedProcess(self):
rects = []
if len(self.pendingWorker) > 0 and self.pendingWorker[0].ready():
task = self.pendingWorker.popleft()
frame, curTime = task.get()
self.latency.update(clock() - curTime)
draw_str(frame, (20, config.VIDEO_WIDTH - 20),
"Latency: %.1f ms" % (self.latency.value * 1000))
draw_str(frame, (20, config.VIDEO_WIDTH - 35),
"FPS: %d" % (1 / self.frameInterval.value))
#print("Latency %lf" % (self.latency.value*1000))
#print("FPS: %d" % (1/self.frameInterval.value))
self.outFrames.append(frame)
#cv2.imshow('Processed Video', frame)
#cv2.waitKey(1)
if len(self.pendingWorker) < self.numThread:
frame = self.stream.read()
t = clock()
self.frameInterval.update(t - self.lastFrameTime)
self.lastFrameTime = t
task = self.workerPool.apply_async(process, (copy.copy(frame), t))
self.pendingWorker.append(task)
def stop(self):
workerPool.terminate()
pendingWorker.clear()
def main():
import sys
try:
fn = sys.argv[1]
except:
fn = 0
cap = video.create_capture(fn)
def process_frame(frame, t0):
# some intensive computation...
frame = cv.medianBlur(frame, 19)
frame = cv.medianBlur(frame, 19)
return frame, t0
threadn = cv.getNumberOfCPUs()
pool = ThreadPool(processes=threadn)
pending = deque()
threaded_mode = True
latency = StatValue()
frame_interval = StatValue()
last_frame_time = clock()
while True:
while len(pending) > 0 and pending[0].ready():
res, t0 = pending.popleft().get()
latency.update(clock() - t0)
draw_str(res, (20, 20), "threaded : " + str(threaded_mode))
draw_str(res, (20, 40),
"latency : %.1f ms" % (latency.value * 1000))
draw_str(
res, (20, 60),
"frame interval : %.1f ms" % (frame_interval.value * 1000))
cv.imshow('threaded video', res)
if len(pending) < threadn:
_ret, frame = cap.read()
t = clock()
frame_interval.update(t - last_frame_time)
last_frame_time = t
if threaded_mode:
task = pool.apply_async(process_frame, (frame.copy(), t))
else:
task = DummyTask(process_frame(frame, t))
pending.append(task)
ch = cv.waitKey(1)
if ch == ord(' '):
threaded_mode = not threaded_mode
if ch == 27:
break
print('Done')
def trackGoals():
print('tracking')
threadn = cv2.getNumberOfCPUs()
pool = ThreadPool(processes=threadn)
pending = deque()
threaded_mode = True
latency = StatValue()
frame_interval = StatValue()
last_frame_time = clock()
while True:
while len(pending) > 0 and pending[0].ready():
res, t0 = pending.popleft().get()
latency.update(clock() - t0)
draw_str(res, (20, 20), "threaded : " + str(threaded_mode))
draw_str(res, (20, 40),
"latency : %.1f ms" % (latency.value * 1000))
draw_str(
res, (20, 60),
"frame interval : %.1f ms" % (frame_interval.value * 1000))
cv2.imshow('threaded video', res)
if len(pending) < threadn:
ret, frame = cap.read()
if frame is not None:
t = clock()
frame_interval.update(t - last_frame_time)
last_frame_time = t
if threaded_mode:
task = pool.apply_async(process_frame, (frame.copy(), t))
else:
task = DummyTask(process_frame(frame, t))
pending.append(task)
ch = cv2.waitKey(1)
if ch == ord(' '):
threaded_mode = not threaded_mode
if ch == 27:
break
cv2.destroyAllWindows()
return frame, t0
threadn = cv2.getNumberOfCPUs()
pool = ThreadPool(processes = threadn)
pending = deque()
threaded_mode = True
latency = StatValue()
frame_interval = StatValue()
last_frame_time = clock()
while True:
while len(pending) > 0 and pending[0].ready():
''' '''
res, t0 = pending.popleft().get()
latency.update(clock() - t0)
draw_str(res, (20, 20), "Latency: %.1f ms" % (latency.value*1000))
draw_str(res, (100, 20), "Frame interval: %.1f ms" % (frame_interval.value*1000))
print('Interval: %.lf ms',(frame_interval.value*1000))
#cv2.imshow('threaded video', res)
frame = cv2.medianBlur(frame, 19)
if len(pending) < threadn:
#camera.capture(rawCap, format = "bgr")
#frame = rawCap.array
frame = cap.read()
t = clock()
frame_interval.update(t - last_frame_time)
last_frame_time = t
if threaded_mode:
task = pool.apply_async(process_frame, (copy.copy(frame), t))
#task = pool.apply_async(process_frame, (frame, t))
def image_cap():
d=[]
print(__doc__)
try:
fn = sys.argv[1]
except:
fn = 0
cap = video.create_capture(fn)
cap.set(cv.CAP_PROP_FPS, 12)
def process_frame(frame, t0):
# some intensive computation...
#frame = cv.medianBlur(frame, 19)
#frame = cv.medianBlur(frame, 19)
return frame, t0
threadn = cv.getNumberOfCPUs()
pool = ThreadPool(processes = threadn)
pending = deque()
threaded_mode = True
latency = StatValue()
frame_interval = StatValue()
last_frame_time = clock()
while True:
while len(pending) > 0 and pending[0].ready():
res, t0 = pending.popleft().get()
latency.update(clock() - t0)
draw_str(res, (20, 20), "threaded : " + str(threaded_mode))
draw_str(res, (20, 40), "latency : %.1f ms" % (latency.value*1000))
draw_str(res, (20, 60), "frame interval : %.1f ms" % (frame_interval.value*1000))
res=cv.resize(res,(176,100))
cv2_im = cv.cvtColor(res, cv.COLOR_BGR2RGB)
pil_im = Image.fromarray(cv2_im)
d.append(np.array(pil_im))
if len(d)==32:
t1 = data_input(d[0:16])
t2 = data_input(d[16:32])
in_x = np.array([t1, t2])
in_x = np.reshape(in_x, (2, 16, 128, 128, 3))
start = time.clock()
#p = Pool(1)
#p.map(evaluate, in_x)
evaluate(in_x)
elapsed = time.clock()
elapsed = elapsed - start
print("Time spent in (function name) is: ", elapsed)
d=[]
cv.imshow('threaded video', res)
if len(pending) < threadn:
ret, frame = cap.read()
t = clock()
frame_interval.update(t - last_frame_time)
last_frame_time = t
if threaded_mode:
task = pool.apply_async(process_frame, (frame.copy(), t))
else:
task = DummyTask(process_frame(frame, t))
pending.append(task)
ch = cv.waitKey(1)
if ch == ord(' '):
threaded_mode = not threaded_mode
if ch == 27:
break
cv.destroyAllWindows()
def run(self):
print(__doc__)
wait_key()
self.computed_frame = self.get_raw_frame()
namedWindow(WINDOW_NAME)
# Create video of Frame sequence -- define the codec and create VideoWriter object
fourcc = VideoWriter_fourcc(*'XVID')
cols = int(self.video_capture_obj.get(CAP_PROP_FRAME_WIDTH))
rows = int(self.video_capture_obj.get(CAP_PROP_FRAME_HEIGHT))
vid_out = VideoWriter(VIDEO_OUTPUT_FNAME, fourcc, 20.0, (cols, rows))
# Set up multiprocessing
num_threads = getNumberOfCPUs()
pool = ThreadPool(processes=num_threads)
pending = deque()
# initialize time variables
latency = StatValue()
frame_interval = StatValue()
# main program loop
while True:
while pending and pending[0].ready(
): # there are frames in the queue
pending.popleft().get()
latency.update(clock() - self.current_frame_time)
# plot info on threading and timing on the current image
# comment out the next 3 lines to skip the plotting
draw_str(self.computed_frame, (20, 20),
"threaded : " + str(self.threaded_mode))
draw_str(self.computed_frame, (20, 40),
"latency : %.1f ms" % (latency.value * 1000))
draw_str(
self.computed_frame, (20, 60),
"frame interval : %.1f ms" %
(frame_interval.value * 1000))
# write output video frame
if self.writing_frame_to_video:
vid_out.write(self.computed_frame)
# show the current image
imshow(WINDOW_NAME, self.computed_frame)
if len(
pending
) < num_threads: # fewer frames than thresds ==> get another frame
# get frame
if self.threaded_mode:
task = pool.apply_async(self.process_frame)
else:
task = DummyTask(self.process_frame())
frame_interval.update(clock() - self.current_frame_time)
pending.append(task)
# check for a keypress
key = wait_key()
# threaded or non threaded mode
if key == ord(' '):
self.threaded_mode = not self.threaded_mode
# toggle doing_gamma_and_contrast_adjust
if key == ord('a'):
self.toggle_doing_gamma_and_contrast_adjust()
# toggle edges
if key == ord('e'):
self.toggle_showing_edges()
# toggle frame
if key == ord('f'):
self.toggle_showing_frame()
# image difference mode
if key == ord('d'):
self.showing_diff_frames = not self.showing_diff_frames
# display image hue band
if key == ord('h'):
self.showing_hue = not self.showing_hue
# equalize image value band
if key == ord('q'):
self.doing_hist_eq = not self.doing_hist_eq
# threshold the image
if key == ord('t'):
self.toggle_doing_threshold()
# do morphological opening on thresholded image (only applied to thresholded image)
if key == ord('o'):
self.doing_morph_open = not self.doing_morph_open
# write video frames
if key == ord('v'):
self.toggle_writing_frame_to_video()
# ESC terminates the program
if key == ESC_KEY:
break
# release video capture object
self.video_capture_obj.release()
# release video output object
vid_out.release()
destroyAllWindows()
