wilmer@veer:~/src/chroma$ cat test.py 
#!/usr/bin/env python3

VID = "/dev/v4l/by-id/usb-046d_HD_Pro_Webcam_C920_DDFB217F-video-index0"
BACK = "back.mp4"
RES = (640, 360)  # VGA but 16:9
LOOPBACK = "/dev/video6"

import argparse
import subprocess

import numpy as np
import cv2

import pyfakewebcam


parser = argparse.ArgumentParser(description="Chroma key using OpenCV background subtraction")
parser.add_argument("-b", "--background", help="Background image or animation", default=BACK)
parser.add_argument("-c", "--camera", help="Camera device", default=VID)
parser.add_argument("-r", "--resolution", help="Capture resolution", default=RES, nargs=2, type=int, metavar=("W", "H"))
parser.add_argument("-l", "--loopback", help="v4l2loopback device", default=LOOPBACK)
parser.add_argument("-s", "--show", help="Show result in own window", action="store_true")
args = parser.parse_args()


cap = cv2.VideoCapture(args.camera)
cap.set(3, args.resolution[0])
cap.set(4, args.resolution[1])
fgbg = cv2.createBackgroundSubtractorMOG2(history=50, detectShadows=False)

subprocess.Popen(["v4l2-ctl", "-d", args.camera, "-c", "exposure_auto=3"]).communicate()

# Let camera do auto-exposure, and let MOG2 do its learning.
for i in range(25):
	ret, frame = cap.read()
	fgmask = fgbg.apply(frame, learningRate=1)

subprocess.Popen(["v4l2-ctl", "-d", args.camera, "-c", "exposure_auto=1"]).communicate()

back_still = cv2.imread(args.background)
if isinstance(back_still, np.ndarray):
	back = back_still
	back_move = None
else:
	back_move = cv2.VideoCapture(args.background)
	_, back = back_move.read()  # Waste the first frame, sorry!

print(back.shape)
back_res = tuple(back.shape[1::-1])
back_ratio = back_res[0] / back_res[1]
print(back_ratio)
if back_ratio >= (args.resolution[0] / args.resolution[1]):
	# background (therefore result we'll dump on loopback) is wider than input.
	# equal height for both, paste camera at non-0 x.
	out_res = (int(args.resolution[1] * back_ratio) & ~1, args.resolution[1])
	fg_offset = (int((out_res[0] - args.resolution[0]) / 2), 0)
else:
	# background is narrower than input. paste camera at bottom, non-0 y.
	out_res = (args.resolution[0], int(args.resolution[0] / back_ratio) & ~1)
	fg_offset = (0, out_res[1] - args.resolution[1])

print(back_res)
print(back_ratio)
print(out_res)
print(fg_offset)

if isinstance(back_still, np.ndarray):  # dumbfuck numpy doesn't like being treated as bool.
	back_still = cv2.resize(back_still, out_res)

outcam = pyfakewebcam.FakeWebcam(args.loopback, *out_res)

#os.exit(1)

face_finder = cv2.CascadeClassifier("face.xml")


def overlay_image_alpha(img, img_overlay, pos, alpha_mask):
	"""Overlay img_overlay on top of img at the position specified by
	pos and blend using alpha_mask.

	Alpha mask must contain values within the range [0, 1] and be the
	same size as img_overlay.
	"""

	x, y = pos

	# Image ranges
	y1, y2 = max(0, y), min(img.shape[0], y + img_overlay.shape[0])
	x1, x2 = max(0, x), min(img.shape[1], x + img_overlay.shape[1])

	# Overlay ranges
	y1o, y2o = max(0, -y), min(img_overlay.shape[0], img.shape[0] - y)
	x1o, x2o = max(0, -x), min(img_overlay.shape[1], img.shape[1] - x)

	# Exit if nothing to do
	if y1 >= y2 or x1 >= x2 or y1o >= y2o or x1o >= x2o:
		return

	channels = img.shape[2]

	alpha = alpha_mask[y1o:y2o, x1o:x2o]
	alpha_inv = 1.0 - alpha

	for c in range(channels):
		img[y1:y2, x1:x2, c] = (alpha * img_overlay[y1o:y2o, x1o:x2o, c] + alpha_inv * img[y1:y2, x1:x2, c])


show = "o"  # show Output

while(1):
	ret, frame = cap.read()

	fgmask = fgbg.apply(frame, learningRate=0)

	if False:
		mask = np.zeros(fgmask.shape)
		
		bw = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
		faces = face_finder.detectMultiScale(bw, 1.1, 4)
		for face in faces:
			x1, y1 = face[0:2]
			x2, y2 = (x1 + face[2]), (y1 + face[3])
			cv2.rectangle(fgmask, (x1, y1), (x2, y2), 1, 0)
			#cv2.rectangle(fgmask, (x1, y1), (x2, y2), 1, 0)


		#fgmask = fgmask * mask
	
	fgmask = fgmask / 255.0
	
	fgmask = cv2.GaussianBlur(fgmask, (11, 11), 0)
	ret, fgmask = cv2.threshold(fgmask, .6, 1, cv2.THRESH_TOZERO)

	if back_move:
		ret = False
		while not ret:
			ret, back = back_move.read()
			if not ret:
				back_move = cv2.VideoCapture(args.background)
		res = cv2.resize(back, out_res)
	else:
		res = np.copy(back_still)
	
	overlay_image_alpha(res, frame, fg_offset, fgmask)

	outcam.schedule_frame(res)
	if args.show:
		# Show it flipped just for our own view.
		if show == "m":
			cv2.imshow("chroma", cv2.flip(fgmask, 1))
		else:
			cv2.imshow("chroma", cv2.flip(res, 1))

	try:
		key = chr(cv2.waitKey(1))
	except ValueError:
		key = "\0"
	
	if key == "q":
		break
	elif key in "mo":
		show = key


cap.release()
cv2.destroyAllWindows()

# Restore what I assume is the default..
subprocess.Popen(["v4l2-ctl", "-d", args.camera, "-c", "exposure_auto=3"]).communicate()