def image_demo(ground_file, unknown_file, zoom, subject): ''' function which enhances the resolution of image files ''' # init image enhancer (Neural Enhance) object enhancer = neural_enhance() # intialize the ground, training image ground_img = init_img(ground_file) # init an unknown image # against which to compare the ground image unknown_img = init_img(unknown_file) # initialize image which will become doubled image unknown_img_x2 = init_img(unknown_file) # enhance image: double resolution of unknown image # convert image to np array unknown_img_x2 = np.array(enhancer.process(unknown_img_x2)) # encode training image to ground encoding ground_encode = encode_face(ground_img)[0][0] # newline to console print('\n') # create filename based on input name of subject outpath_subject = '_'.join(subject) # same the ground image to the filepath scipy.misc.imsave('img/ground_img_' + outpath_subject + '.jpg', ground_img) # call function to encode and recognize unenhanced face image unknown_img = recognize_img(ground_encode, subject, unknown_img, 2) # same image with output information to directory scipy.misc.imsave('img/1x_img_' + outpath_subject + '.jpg', unknown_img) # call function to encode and recognize enhanced face image unknown_img_x2 = recognize_img(ground_encode, subject, unknown_img_x2, 1) # same image with output information to directory scipy.misc.imsave('img/2x_img_' + outpath_subject + '.jpg', unknown_img_x2)
def compare_subject(grd, exp): ''' compare the training image with an unknown image ''' # return the encoding and locations of an unknown face encs, locs = encode_face(exp) # condition to determine if face was found in image # if no encoding, skip comparisons if encs: # get first encoding from list of face encodings encoding = encs[0] # make a comparison between training and experimental face # returns true if face is recognized, false if not # returns magnitude of difference between # training and unknown face results, distance = tolerance_face([grd], encoding) # unpack first values of lists of if face is recognized, # and location of face, and magnitude of similarity res, loc, dist = results[0], locs[0], distance[0] # unpack each corner of the rectangle top, bottom, left, right = loc.top(), loc.bottom(), loc.left( ), loc.right() # find area of face area = (right - left) * (bottom - top) # return tuple of # face is recognized # magnitude between faces # and area of recognized face return res, dist, area # condition if no face is found in image else: # return false, size of face is 0 return False, 1.0, 0
def recognize_img(ground_encode, subject, unknown_img, text_factor): ''' function to recognize faces in images based on inputs of the training encoding the name of the subject the unknown image ''' # create coding and location of unknown image unknown_encode, unknown_locations = encode_face(unknown_img) # iterate through encodings and locations of faces for unknown, rect in zip(unknown_encode, unknown_locations): # determine if training face is in unknown image results = recognize_face([ground_encode], unknown) # get first element of result list result = results[0] # condition to determine if face is recognized in unknown if result: # condition if result is a list if isinstance(subject, list): # join array into string representing name subtitle = ' '.join(subject) # condition if result is string else: # set string name to name subtitle = subject # condition if face is not recognized in unknown else: # subject 'name' is unknown subtitle = 'Unknown' # output the name of the subject if recognized # or unknown if the subject is not recognized print(subtitle) # get corner of the rectangle drawn around recognized face top, bottom, left, right = rect.top(), rect.bottom(), rect.left( ), rect.right() # set font for subtitle of subject or unknown font = cv2.FONT_HERSHEY_DUPLEX # draw rectangle around the face recognized cv2.rectangle(unknown_img, (left, top), (right, bottom), (0, 255, 0), 2 // text_factor) # draw name to the image, either subject or unknown cv2.putText(unknown_img, subtitle, (40 // text_factor, len(unknown_img) - 10 // text_factor), font, 1.0 / text_factor, (255, 255, 255), 1) # return the processed image return unknown_img
def recognize_video(ground_file, unknown_file, subject): ''' function to determine if the dlib face recognition is able to match the ground subject with the unknown ''' # initialize ground image ground_img = init_img(ground_file) # an encoding of the ground subject # against which to match known = encode_face(ground_img)[0][0] # import the video stream vid = cv2.VideoCapture(unknown_file) # iterate through frames there are still frames while vid.isOpened(): # read a single frame of the video ret, frame = vid.read() # condition if the current frame is readable if ret: # get face encoding of images 'in the wild' # including spatial positions of each face unknowns, locations = encode_face(frame) # iterate through each encoding and location for unknown, rect in zip(unknowns, locations): # return array of whether subject/known face # matches the unknown faces results = recognize_face([known], unknown) # get first element of results, true or false result = results[0] # if subject recognized, print subject name if result: # join the subject name into single string subtitle = ' '.join(subject) # if subject not recognized, print unknown else: # output the string indicating # that a person is not known subtitle = 'Unknown person' # get the corners of the face locations top, bottom, left, right = rect.top(), rect.bottom( ), rect.left(), rect.right() # output green rectangle around # the area the face is recognized cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) # output placard at base of recognition rectangle cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED) # set font to predefined opencv font font = cv2.FONT_HERSHEY_DUPLEX # output text with subject name to bottom of rectangle cv2.putText(frame, subtitle, (left + 6, bottom - 6), font, 1.0, (255, 255, 255), 1) # display the current frame to ffmpeg console cv2.imshow('', frame) # condition allows exiting of the loop # if 'q' is pressed or 'x' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): # break out of loop if condition is true break # if frame is unreadable, break from while else: # break if frame is unreadable break # closes alread opened file or camera vid.release() # terminate the windows from opencv cv2.destroyAllWindows()
def video_demo(ground_file, unknown_file, subject): ''' create a video demo with face recognition for any video file, whether ehnahced or not ''' # import training image as numpy array ground_img = init_img(ground_file) # return encoding scheme for training image # used to be compared to all other images # encoding is a 128D array of given face known = encode_face(ground_img)[0][0] # import full video as a set of frames # frames is array of unedited video images frames = full_video(unknown_file) # init empty list to be modified video images images = [] # get the length of frames frame_num = len(frames) # iterate through each unedited frame for i in range(frame_num): # get current frame frame = frames[i] # create recognition and encoding frames # create face encodings and locations # encoding is a 128D array of given face unknowns, locations = encode_face(frame) # iterate through unknown encodings and locations for unknown, rect in zip(unknowns, locations): # recognize unknown face against the ground # return truthiness array of which faces are recognized results = recognize_face([known], unknown) # get first results # usually result array is 1 element list result = results[0] # condition if face is recognized if result: # make a name of the subject recognized # if they face is recognized # based on the above encoding subtitle = ' '.join(subject) # condition if face is not recognized else: # add a default, unknown subtitle # if face is not recognized subtitle = '???' # get each corner of the rectangle # which indicates if a face is recognized top, bottom, left, right = rect.top(), rect.bottom(), rect.left( ), rect.right() # draw the rectangle bordering the face with a red box cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) # draw solid rectangle at bottom of face box cv2.rectangle(frame, (left, bottom + 20), (right, bottom), (0, 0, 255), cv2.FILLED) # get the font of the text font = cv2.FONT_HERSHEY_DUPLEX # draw the text to the solid bordering # beneath the face if recognized cv2.putText(frame, subtitle, (left + 4, bottom + 16), font, 1.0, (255, 255, 255), 1) # add processed frame to the array of processed frames images.append(frame) # print the frame number that is printed to console # this gives a primitive timescale print(i + 1, '/', frame_num) # get the dimensions of the processed image array # for use of resolution output of processed video h, w, l = images[0].shape # get filepath of videofile base = unknown_file.split('.')[0] + '-face-rec.mp4' # create VideoWriter object # at base video file with specified encoding scheme # at specific frame rate with specific frame size writer = cv2.VideoWriter(base, cv2.VideoWriter_fourcc(*"MJPG"), 23, (w, h)) # iterate through array of images for img in images: # write processed file image by image with writer obj writer.write(img) # terminate the video writer writer.release()
def run_experiment(): ''' the experiment to determine rate of similarity between low resolution and high resolution images and returns the stats related to rate of recognition ''' # generate list of subjects in specified directory sub_dir = dir_list('img/') # get conditions of resolution (high,low) cond_dir = gen_cond() # get experiment conditions of various resolutions # including increased resolution and ground, etc... exp_dir = gen_exp() # instanciate object which enhances resolution of image enhancer = neural_enhance() # gen data structure which holds experimental results exp_res = gen_exp_res(sub_dir, exp_dir) # iterate through every file which represents subject # in specified file directory for sub in sub_dir: # print the subject number to the terminal print(sub) # initialize the ground truth training image grd_img = gen_img(sub, 'ground') # create dictionary of images at various exp conditions imgs = {c: gen_img(sub, c) for c in cond_dir} # create offset by which to query control test image off = (int(sub) + (len(sub_dir)) // 2) % len(sub_dir) # if subject is less than ten, append with zero digit # to make file dir string two chars long if off < 10: # add zero digit to front of string less than 10 off = '0' + str(off) # condition if file less than 10 else: # convert int of filepath to str off = str(off) # generate false positive, high resolution control image imgs['highf'] = gen_img(off, 'high') # generate false positive, low resolution control image imgs['lowf'] = gen_img(off, 'low') # generate enhanced resolution image from low res image imgs['x2'] = enhancer.process(imgs['low']) # generate enhanced resolution image from low res false positive imgs['x2f'] = enhancer.process(imgs['lowf']) # encode image from ground truth training image grd_enc = encode_face(grd_img)[0][0] # iterate through each image in experimental groups for key, img in imgs.items(): # comparison between ground truth training image # and image in each experimental group match, dist, size = compare_subject(grd_enc, img) # add match to match experimental results # if true, adds 1 to sum # if false, adds 0 to sum exp_res[sub][key]['match'] += match # increment magnitude comparison # to determine 'closeness' of each face exp_res[sub][key]['dist'] += dist # add size of each face exp_res[sub][key]['size'] += size # return structure of data results contains # all data across experimental categories return exp_res