This project is a virtual camera that will be made using OpenCV which will enable user to hide his/her face during video call and only outline of their face will be seen.


There are many reasons when users don't wish to show their face and don't want the other person to recognize their identity from their voice. In simpler words, users wish to hide identity and at the same time have a video chat. There can be various examples like medical help, or if the judge has to provide an unbiased verdict without knowing someone's race, gender, etc. For such reasons, we can use just an outline of the face and the speech will be converted into text and will be displayed below the video.

- This program uses virtual camera technique to convert open cv video output stream into camera input

- It is necessary to have OBS virtual camera plugin to be installed

- When the user runs vcam.py file the virtual camera will be started and he/she can use that camera in any meeting application

- Also user can speak through their microphone and text will be displayed.

1. User face is captured and send into script

2. Face mesh is created and placed on plain canvas

3. At same time user microphone input is taken and converted into text

4. This is saved in text file and then retrieved from there into program function

5. Text is placed in image and send to virtual camera

6. This image now can be displayed in video chat

1. Install OBS virtual camera plugin

2. Attach Webcamera and Microphone to PC

3. Run vcam.py script

4. You can optionally change the image of mask, color of face outline and also background

5. Open any meet application and in camera section select OBS virtual camera

6. You should see privacy virtual camera output on the screen

This program using multiprocessing and it runs 2 functions i.e. "takesinput" and "program" simultaneously.

When user runs the script a plain canvas of specified solid color is created.

On that the face mesh is placed using mediapipe library

Also a face mask can be applied on eyes.

The face mask are placed according to the eye position and also size is mantained in respect of face dimensions.

In takesinput function the microphone input is converted into text using speech recognition library and displayed on the canvas

This image is then send to virtual camera and can me used in any meet application




Tushar Amdoskar

[Tushar's Website](https://tusharamd.github.io/)

Python is best programming language

import cv2

import pyvirtualcam # For making virtual camera

from pyvirtualcam import PixelFormat

import numpy as np

import mediapipe as mp # Face Mesh

import multiprocessing # Enables python to run 2 processes at same time

import time

import speech_recognition as sr # Speech Recognizer

import cvzone as cv

def takesinput():

r = sr.Recognizer()

mic = sr.Microphone(device_index=1)

#print(sr.Microphone.list_microphone_names())

text=""

with mic as source:

while True:

r.adjust_for_ambient_noise(source) # To avoid taking background noise

audio = r.listen(source)

try:

text=r.recognize_google(audio)

except:

pass

#result.value=text

print(text)

fh = open("Utils/words.txt","w+") # Saving Text in words text file (to be retrieved later)

fh.write(text)

print(fh.read(),"from takesinput")

fh.close()

def program():

print(1)

mp_drawing = mp.solutions.drawing_utils # For face mesh

mp_face_mesh = mp.solutions.face_mesh

face_cascade = cv2.CascadeClassifier(r'C:\Users\tusha\AppData\Local\Programs\Python\Python38\Lib\site-packages\cv2\data\haarcascade_frontalface_default.xml')

camera_no=0

'''

vcam = cv2.VideoCapture(camera_no) # Change camera no if camera doesn't detect

if not vcam.isOpened():

raise RuntimeError('Could not open video source')

#Settings for virtual camera

pref_width = 1280

pref_height = 720

pref_fps_in = 30

vcam.set(cv2.CAP_PROP_FRAME_WIDTH, pref_width)

vcam.set(cv2.CAP_PROP_FRAME_HEIGHT, pref_height)

vcam.set(cv2.CAP_PROP_FPS, pref_fps_in)

width = int(vcam.get(cv2.CAP_PROP_FRAME_WIDTH))

height = int(vcam.get(cv2.CAP_PROP_FRAME_HEIGHT))

fps_in = vcam.get(cv2.CAP_PROP_FPS)

print(f'Webcam capture started ({width}x{height} @ {fps_in}fps)') # Prints fps of vcam

###### CUSTOM CHANGES CAN BE MADE HERE #######

images=['Images/mask1.png','Images/mask2.png','Images/mask3.png','Images/mask4.png']

mask_img = cv2.imread(images[0],cv2.IMREAD_UNCHANGED) #### Change this Image to any Eye wear of your choice

colorsavailable=[(255,255,255),(0,255,255),(0,0,255),(255,0,255),(0,0,255),(0,0,0),(100,20,100),(208, 253, 255)]

chooseColor=colorsavailable[0]

bgColor=colorsavailable[6]

##############################################

fps_out = 20

with pyvirtualcam.Camera(width, height, fps_out, fmt=PixelFormat.BGR, print_fps=fps_in) as cam:

print(f'Virtual cam started: {cam.device} ({cam.width}x{cam.height} @ {cam.fps}fps)')

while True:

ret, frame = vcam.read()

faces=face_cascade.detectMultiScale(frame, 1.2, 5, 0, (120, 120), (350, 350)) #Detecting face using face cascade

if not ret:

raise RuntimeError('Error fetching frame')

# Send to virtual cam.

img = np.zeros((480,640,3), dtype=np.uint8)

img.fill(255)

img = np.full((480, 640, 3), bgColor, np.uint8) # Making a plain canvas with specific solid color

face_mesh = mp_face_mesh.FaceMesh(

static_image_mode=True,

max_num_faces=1,

min_detection_confidence=0.5)

results = face_mesh.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) # Landmarks stored here

drawing_spec = mp_drawing.DrawingSpec(color=chooseColor,thickness=1, circle_radius=0)

if not results.multi_face_landmarks:

continue

for face_landmarks in results.multi_face_landmarks:

#print('face_landmarks:', face_landmarks)

mp_drawing.draw_landmarks(

image=img,

landmark_list=face_landmarks,

connections=mp_face_mesh.FACE_CONNECTIONS,

landmark_drawing_spec=drawing_spec,

connection_drawing_spec=drawing_spec)

for ids,landmrk in enumerate(face_landmarks.landmark):

#print(landmrk,ids)

# 25 is for left eye and 339 is for right eye

if ids == 25:

#cv2.putText(img, str(ids), (int(landmrk.x*640),int(landmrk.y*480)), cv2.FONT_HERSHEY_SIMPLEX,0.1, (255,0,255), 1, cv2.LINE_AA)

x1=landmrk.x*640

y1=landmrk.y*480

if ids == 339:

x2=landmrk.x*640

y2=landmrk.y*480

# getting size of canvas and mask image used

hf,wf,cf=img.shape

hb,wb,cb=mask_img.shape

mask_img=cv2.resize(mask_img, (int(x2-x1)+100, int(y2-y1)+100),interpolation=cv2.INTER_AREA)

#try and except used because it causes error when head is not detected

try:

img = cv.overlayPNG(img,mask_img,[int(x1)-40,int(y1)-70])

except:

pass

# Retrieve the detected text from takesinput process

fh = open("Utils/words.txt","r")

text=fh.read()

fh.close()

text = "Captions : " + text

# Place it on canvas

img = cv2.putText(img, str(text), (20,400), cv2.FONT_HERSHEY_SIMPLEX,0.5, (0,0,255), 1, cv2.LINE_AA)

#cv2.imshow("image", img)

cam.send(img)

if cv2.waitKey(1) == ord('q'):

break

# Wait until it's time for the next frame.

cam.sleep_until_next_frame()

p1 = multiprocessing.Process(target=takesinput)

p2 = multiprocessing.Process(target=program)

if __name__ == '__main__':

p1.start() # Starting both process

p2.start()