def __init__(self, capture=None, face_img_path=None, should_mirror=False):
self._window_manager = WindowManager(self.on_keypress)
self._capture_manager = CaptureManager(cv2.VideoCapture(0)) \
if capture is None else CaptureManager(capture)
self._window_name = 'FaceOff'
self._should_mirror = should_mirror
self._face_tracker = FaceTracker()
self._show_face_rect = False
self._swap_face = True
self._template_face = None
if face_img_path is not None:
self._template_face = cv2.imread(face_img_path)
def __init__(self):
self._thread_mode = True
self._windowManager = WindowManager('Minimum Viable Product',
self.on_keypress)
self._amount_frames = 0
self._success_finding_contours = 0
# DroidCam URL
# url = 'http://192.168.55.78:4747/video'
url = 0
self._captureManager = CaptureManager(
cv2.VideoCapture(url), self._windowManager, False)
def __init__(self, window_manager):
self._record_face = 0
self._record_count = 0
self._stopped = True
self._processed = False
self._amount_frames = 0
self._success_finding_contours = 0
self._original_capture = None
self._data = dict()
# DroidCam URL
# url = 'http://192.168.55.51:4747/video'
url = 0
self._capture_manager = CaptureManager(cv2.VideoCapture(url))
self._window_manager = window_manager
def test_manager(self):
sniffer = BaseSnifferDevice()
manager = CaptureManager(controller=sniffer)
time.sleep(1)
for t in range(2):
manager.start_new_task('test%d' % t, 'test owner', 'localhost')
time.sleep(2)
manager.stop_task('test%d' % t)
time.sleep(1)
manager.start_new_task('long test', 'test owner', 'localhost')
time.sleep(60)
manager.stop_task('long test')
time.sleep(1)
for task in manager.get_finished_tasks():
print('Finished: id %s, start %s, stop %s' % (task.id, task.start_time, task.stop_time))
for trace in manager.get_trace_list_by_task_id(task.id):
print('- T: %s' % trace)
manager.shutdown()
time.sleep(2)
class ImageDataRecorder(object):
def __init__(self, window_manager):
self._record_face = 0
self._record_count = 0
self._stopped = True
self._processed = False
self._amount_frames = 0
self._success_finding_contours = 0
self._original_capture = None
self._data = dict()
# DroidCam URL
# url = 'http://192.168.55.51:4747/video'
url = 0
self._capture_manager = CaptureManager(cv2.VideoCapture(url))
self._window_manager = window_manager
@property
def original_capture(self):
return self._original_capture
@property
def data(self):
return self._data
# from CaptureManager
@property
def processing_capture(self):
return self._capture_manager.processed_frame
@property
def roi_capture(self):
return self._capture_manager.roi_frame
def release_frame(self):
self._capture_manager.release_frame()
# Thread
@property
def active(self):
return not self._stopped
@property
def processed(self):
return self._processed
def start(self, face=0, count=100):
print('Start recording')
self._record_face = face
self._record_count = count
self._stopped = False
# TODO: Thread Refactoring
Thread(target=self.get, args=()).start()
return self
def get(self):
self._processed = True
self._amount_frames = 0
self._success_finding_contours = 0
while not self._stopped:
self._capture_manager.enter_frame()
self._original_capture = self._capture_manager.original_frame
if self._original_capture is None:
# self.stop()
continue
if self._capture_manager.roi_frame is None:
self._capture_manager.roi_frame = self._original_capture
# print("Recording: " + str(self._success_finding_contours))
# print("Count: " + str(self._record_count))
self._amount_frames += 1
self._capture_manager.processed_frame, roi_frame = \
processing.process_and_detect(self._original_capture, self._window_manager)
if roi_frame is not None:
self._capture_manager.roi_frame = roi_frame
self._data[self._success_finding_contours * 10 + self._record_face] = self._capture_manager.roi_frame
self._success_finding_contours += 1
color_yellow = (0, 255, 255)
percent_success_finding = round((self._success_finding_contours / self._amount_frames) * 100, 2)
cv2.putText(self._capture_manager.processed_frame, str(percent_success_finding) + "%",
(15, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
cv2.putText(self._capture_manager.processed_frame, str(self._success_finding_contours),
(15, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
self._capture_manager.exit_frame()
if self._success_finding_contours >= self._record_count:
print('Stop recording')
self.stop()
self._processed = False
def stop(self):
self._record_face = 0
self._record_count = 0
# self._data.clear()
self._stopped = True
def write_image(self, filename):
self._capture_manager.write_image(filename)
def is_writing_video(self):
return self._capture_manager.is_writing_video
def start_writing_video(self, filename):
self._capture_manager.start_writing_video(filename)
def stop_writing_video(self):
self._capture_manager.stop_writing_video()
class VideoCaptureApp(object):
def __init__(self, capture=None, face_img_path=None, should_mirror=False):
self._window_manager = WindowManager(self.on_keypress)
self._capture_manager = CaptureManager(cv2.VideoCapture(0)) \
if capture is None else CaptureManager(capture)
self._window_name = 'FaceOff'
self._should_mirror = should_mirror
self._face_tracker = FaceTracker()
self._show_face_rect = False
self._swap_face = True
self._template_face = None
if face_img_path is not None:
self._template_face = cv2.imread(face_img_path)
def run(self):
self._window_manager.create_window(self._window_name)
while self._window_manager.is_window_created(self._window_name):
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
if frame is None:
print "get None frame!"
break
# process frame
# detect face
self._face_tracker.update(frame)
face_num = len(self._face_tracker.faces)
face_rect = None if face_num == 0 else \
self._face_tracker.faces[0].face_rect
if self._show_face_rect:
txt_str = 'face_num: {}'.format(face_num)
for face in self._face_tracker.faces:
x, y, w, h = face.face_rect
cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0),
2)
# only show the 1st face
break
if face_rect is not None and self._swap_face and \
self._template_face is not None:
x, y, w, h = face_rect
template_face = self._template_face.copy()
template_face = cv2.resize(template_face, (w, h))
# simply paste
# frame[y:y+h,x:x+w] = template_face
# or use seamless clone
mask = 255 * np.ones(template_face.shape, template_face.dtype)
center = (x + w / 2, y + h / 2)
frame = cv2.seamlessClone(template_face, frame, mask, center, \
cv2.MIXED_CLONE)
# frame = cv2.seamlessClone(template_face, frame, mask, center, \
# cv2.NORMAL_CLONE)
# show frame window
if self._should_mirror:
# horizontal flipping
frame = cv2.flip(frame, 1)
# draw text
if self._show_face_rect:
cv2.putText(frame, txt_str, (50, 100),
cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 255, 0), 2)
self._window_manager.show_window(self._window_name, frame)
self._capture_manager.exit_frame()
self._window_manager.process_event()
def on_keypress(self, keycode):
if keycode == ord('m'):
self._should_mirror = not self._should_mirror
elif keycode == ord('s'):
self._swap_face = not self._swap_face
elif keycode == ord('f'):
self._show_face_rect = not self._show_face_rect
elif keycode == 27:
# Escape
self._window_manager.destroy_all_window()
class ImageDataRecorder(object):
def __init__(self, window_manager):
self._record_face = 0
self._record_count = 0
self._stopped = True
self._processed = False
self._amount_frames = 0
self._success_finding_contours = 0
self._original_capture = None
self._data = dict()
# DroidCam URL
# url = 'http://192.168.55.129:4747/video'
url = 1
self._capture_manager = CaptureManager(cv2.VideoCapture(url))
self._window_manager = window_manager
@property
def original_capture(self):
return self._original_capture
@property
def data(self):
return self._data
# from CaptureManager
@property
def processing_capture(self):
return self._capture_manager.processed_frame
@property
def roi_capture(self):
return self._capture_manager.roi_frame
def release_frame(self):
self._capture_manager.release_frame()
# Thread
@property
def active(self):
return not self._stopped
@property
def processed(self):
return self._processed
def start(self, face=0, count=100):
print('Start recording')
self._record_face = face
self._record_count = count
self._stopped = False
# TODO: Thread Refactoring
Thread(target=self.get, args=()).start()
return self
def get(self):
self._processed = True
self._amount_frames = 0
self._success_finding_contours = 0
while not self._stopped:
self._capture_manager.enter_frame()
original_capture = self._capture_manager.original_frame
if original_capture is None:
# self.stop()
continue
# (h, w) = original_capture.shape[:2]
# center = (w / 2, h / 2)
# M = cv2.getRotationMatrix2D(center, 270, 1.0)
# self._original_capture = cv2.warpAffine(original_capture, M, (h, w))
self._original_capture = original_capture
self._amount_frames += 1
height, width, _ = self._original_capture.shape
self._capture_manager.processed_frame = self._original_capture.copy(
)
cv2.rectangle(self._capture_manager.processed_frame, (440, 300),
(width - 400, height - 250), (0, 0, 255), 3)
# cv2.rectangle(self._capture_manager.processed_frame,
# (80, 120), (width - 0, height - 260), (0, 0, 255), 3)
self._capture_manager.roi_frame = self._original_capture[
300:height - 250, 440:width - 400]
# self._capture_manager.roi_frame = self._original_capture[120:height - 260, 80:width - 0]
self._data[
self._record_face * 10 + self.
_success_finding_contours] = self._capture_manager.roi_frame
self._success_finding_contours += 1
'''
if self._capture_manager.roi_frame is None:
self._capture_manager.roi_frame = self._original_capture
# print("Recording: " + str(self._success_finding_contours))
# print("Count: " + str(self._record_count))
self._capture_manager.processed_frame, roi_frame = \
processing.process_and_detect(self._original_capture, self._window_manager)
if roi_frame is not None:
self._capture_manager.roi_frame = roi_frame
self._data[self._success_finding_contours * 10 + self._record_face] = self._capture_manager.roi_frame
self._success_finding_contours += 1
color_yellow = (0, 255, 255)
percent_success_finding = round((self._success_finding_contours / self._amount_frames) * 100, 2)
cv2.putText(self._capture_manager.processed_frame, str(percent_success_finding) + "%",
(15, 70), cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
cv2.putText(self._capture_manager.processed_frame, str(self._success_finding_contours),
(15, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
'''
self._capture_manager.exit_frame()
if self._success_finding_contours >= self._record_count:
print('Stop recording')
self.stop()
self._processed = False
def stop(self):
self._record_face = 0
self._record_count = 0
# self._data.clear()
self._stopped = True
def write_image(self, filename):
self._capture_manager.write_image(filename)
def is_writing_video(self):
return self._capture_manager.is_writing_video
def start_writing_video(self, filename):
self._capture_manager.start_writing_video(filename)
def stop_writing_video(self):
self._capture_manager.stop_writing_video()
class MVP(object):
def __init__(self):
self._thread_mode = True
self._windowManager = WindowManager('Minimum Viable Product',
self.on_keypress)
self._amount_frames = 0
self._success_finding_contours = 0
# DroidCam URL
# url = 'http://192.168.55.78:4747/video'
url = 0
self._captureManager = CaptureManager(
cv2.VideoCapture(url), self._windowManager, False)
# self._curveFilter = filters.BGRPortraCurveFilter()
# self._convolutionFilter = filters.FindEdgesFilter()
# self._imageProcessor = image_processor.SimpleImageProcessor()
# self._objectDetector = object_detector.SimpleObjectDetector()
def run(self):
"""Run the main loop."""
threadn = cv2.getNumberOfCPUs()
pool = ThreadPool(processes=threadn)
pending = deque()
# latency = StatValue()
# frame_interval = StatValue()
# last_frame_time = clock()
# TODO: Camera Calibration, Video Stabilization
self._windowManager.create_window()
while self._windowManager.is_window_created:
self._captureManager.enter_frame()
original = self._captureManager.original
self._captureManager.frame = original
# if original is not None:
# output = self.process_and_detect(original)
# self._captureManager.frame = output§
while len(pending) > 0 and pending[0].ready():
output = pending.popleft().get()
# latency.update(clock() - t0)
cv2.putText(output, "threaded : " + str(self._thread_mode),
(15, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
# draw_str(res, (20, 40), "latency : %.1f ms" % (latency.value * 1000))
# draw_str(res, (20, 60), "frame interval : %.1f ms" % (frame_interval.value * 1000))
self._captureManager.frame = output
self._captureManager.exit_frame()
if len(pending) < threadn:
# ret, frame = cap.read()
# t = clock()
# frame_interval.update(t - last_frame_time)
# last_frame_time = t
if self._thread_mode:
task = pool.apply_async(self.process_and_detect, (original.copy(),))
else:
task = DummyTask(self.process_and_detect(original))
pending.append(task)
self._captureManager.exit_frame()
self._windowManager.process_events()
def process_and_detect(self, src):
self._amount_frames += 1
# filters.strokeEdges(src, src)
# self._curveFilter.apply(src, src)
# self._convolutionFilter.apply(src, src)
# self._imageProcessor.process(src, src)
# self._objectDetector.detect(src)
# TODO: Image Preprocessor: removing shadows, small blobs, noise, enhancing, etc
# TODO: Image Processor
processing = self.image_processing_template_one(src)
# gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
# filtering = cv2.bilateralFilter(gray, 1, 10, 120)
# TODO: Object Detector
output = cv2.cvtColor(processing, cv2.COLOR_GRAY2BGR)
success_detect = self.try_detect(input=processing, output=output, post_detect_fn=self.post_detect_draw)
if not success_detect:
# TODO: image_processing_template_two
pass
# TODO: Get 4-contours square counts If zero
# TODO: [For 3D] Wrapping & Transformations
# TODO: to be continued
return output
def image_processing_template_one(self, src):
# TODO: Color space: GRAYSCALE, HSV, ...
gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
# TODO: Convolution, Blurring, ...
# filtering = cv2.bilateralFilter(gray, 1, 10, 120)
filtering = self.image_filtering(gray)
# TODO: Edge detection
# edges = cv2.Canny(gray, 10, 250)
edges = self.edge_detection(filtering)
# TODO: Morphological operations
# kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (7, 7))
# closed = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
closed = self.morphological_transformations(edges)
return closed
def image_filtering(self, src):
diameter = self._windowManager.get_trackbar_value('diameter(for bilateralFilter)')
sigma_color = self._windowManager.get_trackbar_value('sigmaColor(for bilateralFilter)')
sigma_space = self._windowManager.get_trackbar_value('sigmaSpace(for bilateralFilter)')
filtering = cv2.bilateralFilter(src, diameter, sigma_color, sigma_space)
return filtering
def edge_detection(self, src):
threshold_min = self._windowManager.get_trackbar_value('threshold min(for Canny edge detection)')
threshold_max = self._windowManager.get_trackbar_value('threshold max(for Canny edge detection)')
edges = cv2.Canny(src, threshold_min, threshold_max)
return edges
def morphological_transformations(self, edges):
kernel_size = self._windowManager.get_trackbar_value('kernel size(morphological structuring element)')
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_size, kernel_size))
closed = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
return closed
def try_detect(self, input, output, post_detect_fn):
success_standard = self.detect_standard_rects(input, output, post_detect_fn)
if not success_standard:
# TODO: detect_rects_by_lines
pass
return success_standard
def detect_standard_rects(self, input, output, post_detect_fn):
contour_area_points = self._windowManager.get_trackbar_value('Contour area min amount points (*100)')
approx_edges_amount = self._windowManager.get_trackbar_value('Approx edges amount')
_, contours, h = cv2.findContours(input, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
rects_count = 0
for cont in contours:
if cv2.contourArea(cont) > contour_area_points * 100:
arc_len = cv2.arcLength(cont, True)
approx = cv2.approxPolyDP(cont, 0.1 * arc_len, True)
if len(approx) == approx_edges_amount:
post_detect_fn(output, approx)
rects_count += 1
if rects_count > 0:
self._success_finding_contours += 1
color_yellow = (0, 255, 255)
percent_success_finding = round((self._success_finding_contours / self._amount_frames) * 100, 2)
cv2.putText(output, str(percent_success_finding) + "%",
(15, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, color_yellow, 2)
return rects_count > 0
@staticmethod
def post_detect_draw(output, approx):
cv2.drawContours(output, [approx], -1, (255, 0, 0), 2)
def on_keypress(self, keycode):
"""Handle a keypress.
space -> Take a screenshot.
tab -> Start/stop recording a screencast.
escape -> Quit.
"""
if keycode == 32: # space
# self._captureManager.write_image('screenshot.png')
self._thread_mode = not self._thread_mode
elif keycode == 9: # tab
if not self._captureManager.is_writing_video:
self._captureManager.start_writing_video(
'screencast.avi')
else:
self._captureManager.stop_writing_video()
elif keycode == 27: # escape
self._windowManager.destroy_window()
filename = 'cap-%s-%s.btt' % (
time.strftime('%y%m%d_%H%M%S', time.localtime(start_time)),
time.strftime('%y%m%d_%H%M%S', time.localtime(stop_time)))
return filename
def _epoch_time_to_human_readable(timestamp):
return time.strftime('%x %X', time.localtime(timestamp))
def _task_list_to_string(task_list):
str_list = []
for task in task_list:
task_dict = task.to_dict()
str_list.append(task_dict)
return str_list
def sigint_handler(signal, frame):
print('Shutting down service.')
capture_manager.shutdown()
sys.exit(0)
if __name__ == "__main__":
signal.signal(signal.SIGINT, sigint_handler)
sniffer = EllisysController()
capture_manager = CaptureManager(sniffer, split_interval=600)
app.run(host='0.0.0.0', port=5000)