class Cameo(object):
def __init__(self):
self._windowManager = WindowManager('Cameo', self.on_keypress)
self._captureManager = CaptureManager(cv2.VideoCapture(0), self._windowManager, True)
def run(self):
"""Run the main loop."""
self._windowManager.create_window()
while self._windowManager.is_window_created:
self._captureManager.enter_frame()
frame = self._captureManager.frame
if frame is not None:
# TODO: Filter the frame (Chapter 3).
pass
self._captureManager.exit_frame()
self._windowManager.process_events()
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('out.png')
elif keycode == 9: # tab
if not self._captureManager.is_writing_video:
self._captureManager.start_writing_video('out.avi')
else:
self._captureManager.stop_writing_video()
elif keycode == 27: # escape
self._windowManager.destroy_window()
class Detect(object):
def __init__(self):
self._window_manager = WindowManager('Face Detector',
self.on_key_press)
self._capture_manager = CaptureManager(cv2.VideoCapture(0),
self._window_manager, True)
self._face_tracker = FaceTracker()
def run(self):
self._window_manager.create_window()
while self._window_manager.is_window_created:
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
self._face_tracker.update(frame)
self._face_tracker.draw_debug_rects(frame)
self._capture_manager.exit_frame()
self._window_manager.process_events()
def on_key_press(self, keycode):
"""
Keypress handler
escape - quit
:return:
"""
if keycode == 27: # escape
self._window_manager.destroy_window()
class Main:
def __init__(self):
self._windowManager = WindowManager('app')
self._captureManager = CaptureManager(cv2.VideoCapture(0), self._windowManager, True)
self._eventsHandler = EventsHandler(self._captureManager, self._windowManager)
def run(self):
self._windowManager.create_window()
while self._windowManager.is_window_created:
self._captureManager.enter_frame()
self._eventsHandler.process_events()
self._captureManager.exit_frame()
class Cameo(object):
def __init__(self):
self._window_manager = WindowManager('Cameo', self.on_key_press)
self._capture_manager = CaptureManager(cv2.VideoCapture(0), self._window_manager, True)
self._face_tracker = FaceTracker()
self._should_draw_debug_rects = False
self._curve_filter = filters.EmbossFilter() # can use any of applied filters
def run(self):
self._window_manager.create_window()
while self._window_manager.is_window_created:
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
self._face_tracker.update(frame)
faces = self._face_tracker.faces
rects.swap_rects(frame, frame, [face.face_rect for face in faces])
filters.stroke_edges(frame, frame)
self._curve_filter.apply(frame, frame)
if self._should_draw_debug_rects:
self._face_tracker.draw_debug_rects(frame)
self._capture_manager.exit_frame()
self._window_manager.process_events()
def on_key_press(self, keycode):
"""
Keypress handler
space - screen
tab - start/stop recording
x - start/stop debug
escape - quit
:return:
"""
if keycode == 32: # space
self._capture_manager.write_image('screenshot.png')
elif keycode == 9: # tab
if not self._capture_manager.is_writing_video:
self._capture_manager.start_writing_video('screencast.avi')
else:
self._capture_manager.stop_writing_video()
elif keycode == 120: # x
self._should_draw_debug_rects = not self._should_draw_debug_rects
elif keycode == 27: # escape
self._window_manager.destroy_window()
class Cameo(object):
def __init__(self):
self._window_manager = WindowManager('Cameo', self.on_keypress)
self._capture_manager = CaptureManager(cv2.VideoCapture(0), self._window_manager, False)
def run(self):
self._window_manager.create_window()
while self._window_manager.is_window_created:
with self._capture_manager as f:
frame = f.frame
filters.recolor_CMV(frame, frame)
self._window_manager.process_event()
def on_keypress(self, keycode):
if keycode == 27:
self._window_manager.destroy_window()
class Cameo(object):
def __init__(self):
self._window_manager = WindowManager('Cameo', self.on_keypress)
self._capture_manager = CaptureManager(cv2.VideoCapture(0), self._window_manager, True)
# @这是滤波器
# self._curve_filter = filters.FindEdgesFilter4()
def run(self):
"""main loop"""
self._window_manager.create_window()
while self._window_manager.is_window_created:
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
# TUDO(yuwan) filter the frame (chapter 3)
# @这是滤波器方法
# filters.stroke_edges(frame, frame)
# self._curve_filter.apply(frame, frame)
self._capture_manager.exit_frame()
self._window_manager.process_events()
def on_keypress(self, key_code):
"""
handle a keypress
space -> take a screen_shot
tab -> start/stop recording a screen_cast
escape -> quit
:param key_code:
:return:
"""
if key_code == 32: # space
self._capture_manager.write_image("filtered_images/screen_shot.png")
elif key_code == 9: # tab
if not self._capture_manager.is_writing_video:
self._capture_manager.start_writing_video("screen_cast.avi")
else:
self._capture_manager.stop_writing_video()
elif key_code == 27: # escape
self._window_manager.destroy_window()
class Cameo(object):
def __init__(self):
self._window_manager = WindowManager('Cameo', self.on_key_press)
self._capture_manager = CaptureManager(cv2.VideoCapture(0), self._window_manager, True)
self._curve_filter = filters.BGRPortraCurveFilter()
def run(self):
"""Run the main loop"""
self._window_manager.create_window()
while self._window_manager.is_window_created:
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
# filter the frame
filters.stroke_edges(frame, frame)
# emulating Portra film colors
self._curve_filter.apply(frame, frame)
self._capture_manager.exit_frame()
self._window_manager.process_events()
def on_key_press(self, key_code):
"""Handle a key press.
space -> take a snapshot
tab -> start/stop recording a screen cast
escape -> quit
"""
if key_code == 32: # space
self._capture_manager.write_image('screenshot.png')
elif key_code == 9: # tab
if not self._capture_manager.is_writing_video:
self._capture_manager.start_writing_video('screencast.avi')
else:
self._capture_manager.stop_writing_video()
elif key_code == 27: # escape
self._window_manager.destory_window()
class VideoAnalysis:
def __init__(self, create_tracker_fun, file_path):
self._window_manager = WindowManager(
file_path, self.on_keypress
)
self._capture_manager = CaptureManager(
cv2.VideoCapture(file_path), self._window_manager, width=640
)
self._track_marks = []
self._create_tracker_fun = create_tracker_fun
self._multi_tracker = cv2.MultiTracker_create()
self._initial_roi_histograms = []
self._base_angle = None
self._angle_change = []
self._frame_no = 0
def run(self):
self._window_manager.create_window()
self._capture_manager.paused = False
frame_generator = self.frames()
frame = next(frame_generator)
rois = detect(frame)
self.save_rois(frame, rois)
previous_angle = None
while self._window_manager.window_created and frame is not None:
frame = next(frame_generator)
ok, rois = self._multi_tracker.update(frame)
if ok and len(rois) > 1:
upper, lower = Rectangle(*rois[0]), Rectangle(*rois[1])
if not self._frame_no % 100:
new_rois = detect(frame)
if len(new_rois) >= 2:
new_similarity = roi_similarity(frame, *new_rois[:2])
old_similarity = roi_similarity(frame, upper, lower)
current_overlap = rois_overlap(upper, lower)
if old_similarity < 0.4 and new_similarity - old_similarity > 0.4:
for pair in zip(new_rois[:2], [upper, lower]):
overlap = rois_overlap(*pair)
if current_overlap > 0.2 or overlap < 0.4:
self.save_rois(frame, new_rois[:2])
current_angle = self.to_angle(upper, lower)
if current_angle != previous_angle:
previous_angle = current_angle
self._angle_change.append(self.to_angle(upper, lower))
base_angle_line = (
Point(upper.x, upper.y + upper.h//2),
Point(lower.x, upper.y + upper.h//2))
current_angle_line = (
Point(upper.x, upper.y + upper.h//2),
self.count_point(current_angle, upper, lower))
self._capture_manager.add_lines([current_angle_line, base_angle_line])
self._capture_manager.add_rois([upper, lower])
if not (previous_angle and self._capture_manager.paused):
print(current_angle)
elif not self._capture_manager.paused:
print("Tracking failure")
if frame is not None and not self._frame_no % 15:
new_rois = detect(frame)
self.save_rois(frame, new_rois)
self._window_manager.process_events()
if frame is None:
self._window_manager.destroy_window()
def save_rois(self, frame, rois):
self._multi_tracker = cv2.MultiTracker_create()
self._track_marks = []
for bounding_box in rois[:2]:
self._track_marks.append(bounding_box)
roi_fragment = bounding_box.clip_to_fit(frame.shape).sample_from_image(frame)
histogram = cv2.calcHist(roi_fragment, [0], None, [100], [0, 255])
self._initial_roi_histograms.append(histogram)
self._multi_tracker.add(self._create_tracker_fun(), frame, bounding_box.parameters)
if len(self._track_marks) >= 2:
self._base_angle = Point.point_angle(
self._track_marks[0].corners[0],
self._track_marks[1].corners[0]
)
def to_angle(self, upper, lower):
new_angle = Point.point_angle(upper.corners[0], lower.corners[0])
result = new_angle - self._base_angle
if result < -180:
result = 360 + result
return result
def count_point(self, angle, upper, lower):
b = math.hypot(lower.x - upper.x, 0)
c = b / math.cos(math.radians(angle))
a = c * math.sin(math.radians(angle))
new_y = upper.y + 0.5*upper.h + a
return Point(lower.x, new_y)
def frames(self):
while True:
self._capture_manager.enter_frame()
yield self._capture_manager.frame
self._frame_no += 1
self._capture_manager.exit_frame()
def on_keypress(self, keycode):
if keycode == 32: # space
print("screenshot created")
self._capture_manager.write_image('out/screenshot.png')
elif keycode == 9: # tab
if not self._capture_manager.is_writing_video:
print("recording started")
self._capture_manager.start_writing_video('out/screencast.avi')
else:
print("recording finished")
self._capture_manager.stop_writing_video()
elif keycode == 27: # escape
print("exiting")
self._window_manager.destroy_window()
elif keycode == 0x0D: # enter
if not self._capture_manager.paused:
print("stop film")
self._capture_manager.paused = True
else:
print("start film")
self._capture_manager.paused = False
class App(object):
def __init__(self, args):
assert args.identity is not None
assert os.path.exists(args.output_dir)
self._output_dir = os.path.join(args.output_dir, args.identity)
if not os.path.exists(self._output_dir):
os.mkdir(self._output_dir)
self._identity = args.identity
self._window_manager = WindowManager('Face Capture', self.on_keypress)
self._capture_manager = CaptureManager(cv2.VideoCapture(0),
self._window_manager, True)
self._img_count = long(0)
self._auto_write_img = False
self._cropped = None
self._image_size = args.image_size
def run(self):
"""Run the main loop"""
self._window_manager.create_window()
while self._window_manager.is_window_created:
self._capture_manager.enter_frame()
frame = self._capture_manager.frame
if frame is not None:
# face detection
faces = api.detect_faces(frame)
for face in faces:
self._cropped = cv2.resize(frame[face[1]:face[3],
face[0]:face[2]],
dsize=(self._image_size,
self._image_size),
interpolation=cv2.INTER_CUBIC)
if self._auto_write_img:
# face cropped from screen shot
self.write_image(self._cropped)
# mark face rectangle
cv2.rectangle(frame, (face[0], face[1]),
(face[2], face[3]), (0, 255, 0), 2)
self._capture_manager.exit_frame()
self._window_manager.process_events()
def on_keypress(self, keycode):
if keycode == 9:
# tab
self._auto_write_img = not self._auto_write_img
elif keycode == 32:
# space
self.write_image(self._cropped)
elif keycode == 27:
# escape
self._window_manager.destroy_window()
def write_image(self, cropped):
if cropped is None:
print 'Cropped is none'
return
filename = os.path.join(self._output_dir,
(self._identity.lower() +
('_%06d.jpg' % self._img_count)))
mirror_filename = os.path.join(
self._output_dir,
(self._identity.lower() + ('_%06d_mirror.jpg' % self._img_count)))
print 'Saving image ', filename
# save to disk
cv2.imwrite(filename, cropped)
print 'Saving mirrored image ', mirror_filename
mirror_cropped = np.fliplr(cropped).copy()
cv2.imwrite(mirror_filename, mirror_cropped)
# increase count
self._img_count += 1
