def averager(imgpaths, dest_filename=None, width=500, height=600, background='black', blur_edges=False, out_filename='result.png', plot=False): size = (height, width) images = [] point_set = [] for path in imgpaths: img, points = load_image_points(path, size) if img is not None: images.append(img) point_set.append(points) if len(images) == 0: raise FileNotFoundError('Could not find any valid images.' + ' Supported formats are .jpg, .png, .jpeg') if dest_filename is not None: dest_img, dest_points = load_image_points(dest_filename, size) if dest_img is None or dest_points is None: raise Exception('No face or detected face points in dest img: ' + dest_filename) else: dest_img = np.zeros(images[0].shape, np.uint8) dest_points = locator.average_points(point_set) num_images = len(images) result_images = np.zeros(images[0].shape, np.float32) for i in range(num_images): result_images += warper.warp_image(images[i], point_set[i], dest_points, size, np.float32) result_image = np.uint8(result_images / num_images) face_indexes = np.nonzero(result_image) dest_img[face_indexes] = result_image[face_indexes] mask = blender.mask_from_points(size, dest_points) if blur_edges: blur_radius = 10 mask = cv2.blur(mask, (blur_radius, blur_radius)) if background in ('transparent', 'average'): dest_img = np.dstack((dest_img, mask)) if background == 'average': average_background = locator.average_points(images) dest_img = blender.overlay_image(dest_img, mask, average_background) print('Averaged {} images'.format(num_images)) plt = plotter.Plotter(plot, num_images=1, out_filename=out_filename) plt.save(dest_img) plt.plot_one(dest_img) plt.show()
def morph(src_img, src_points, dest_img, dest_points, video, width=500, height=600, num_frames=20, fps=10, out_frames=None, out_video=None, alpha=False, plot=False, keep_bg=False): """ Create a morph sequence from source to destination image :param src_img: ndarray source image :param src_img: source image array of x,y face points :param dest_img: ndarray destination image :param dest_img: destination image array of x,y face points :param video: facemorpher.videoer.Video object """ size = (height, width) stall_frames = np.clip(int(fps * 0.15), 1, fps) # Show first & last longer plt = plotter.Plotter(plot, num_images=num_frames, out_folder=out_frames) num_frames -= (stall_frames * 2) # No need to process src and dest image plt.plot_one(src_img) video.write(src_img, 1) # Produce morph frames! for percent in np.linspace(1, 0, num=num_frames): points = locator.weighted_average_points(src_points, dest_points, percent) src_face = warper.warp_image(src_img, src_points, points, size) end_face = warper.warp_image(dest_img, dest_points, points, size) average_face = blender.weighted_average(src_face, end_face, percent) average_face = alpha_image(average_face, points) if alpha else average_face # Average background (find transparent pixel, remove alpha from face image, and than replace transparent with averaged bg) if (keep_bg): average_background = blender.weighted_average( src_img, dest_img, percent) average_face = alpha_image(average_face, points) transparent_pixel = average_face[..., 3] == 0 average_face = average_face[..., :3] average_face[transparent_pixel] = average_background[ transparent_pixel] plt.plot_one(average_face) plt.save(average_face) video.write(average_face) plt.plot_one(dest_img) video.write(dest_img, stall_frames) plt.show()
def morph(src_img, src_points, dest_img, dest_points, video, width=500, height=600, num_frames=20, fps=10, out_frames=None, out_video=None, plot=False, background='black'): """ Create a morph sequence from source to destination image :param src_img: ndarray source image :param src_points: source image array of x,y face points :param dest_img: ndarray destination image :param dest_points: destination image array of x,y face points :param video: facemorpher.videoer.Video object """ size = (height, width) stall_frames = np.clip(int(fps * 0.15), 1, fps) # Show first & last longer plt = plotter.Plotter(plot, num_images=num_frames, out_folder=out_frames) num_frames -= (stall_frames * 2) # No need to process src and dest image plt.plot_one(src_img) video.write(src_img, 1) # Produce morph frames! for percent in np.linspace(1, 0, num=num_frames): points = locator.weighted_average_points(src_points, dest_points, percent) src_face = warper.warp_image(src_img, src_points, points, size) end_face = warper.warp_image(dest_img, dest_points, points, size) average_face = blender.weighted_average(src_face, end_face, percent) if background in ('transparent', 'average'): mask = blender.mask_from_points(average_face.shape[:2], points) average_face = np.dstack((average_face, mask)) if background == 'average': average_background = blender.weighted_average( src_img, dest_img, percent) average_face = blender.overlay_image(average_face, mask, average_background) plt.plot_one(average_face) plt.save(average_face) video.write(average_face) plt.plot_one(dest_img) video.write(dest_img, stall_frames) plt.show()
def average_face(imgpaths, width=500, height=500, background='black', blur_edges=False, out_filename='result.jpg'): size = (height, width) images = [] point_set = [] for path in imgpaths: img, points = load_image_points(path, size) if img is not None: images.append(img) point_set.append(points) if len(images) == 0: raise FileNotFoundError( 'Could not find any valid images. Supported formats are .jpg, .png, .jpeg' ) dest_img, dest_points = load_image_points(REFERENCE_IMG_PATH, size) num_images = len(images) result_images = np.zeros(images[0].shape, np.float32) for i in range(num_images): result_images += warper.warp_image(images[i], point_set[i], dest_points, size, np.float32) result_image = np.uint8(result_images / num_images) face_indexes = np.nonzero(result_image) dest_img[face_indexes] = result_image[face_indexes] mask = blender.mask_from_points(size, dest_points) if blur_edges: blur_radius = 10 mask = cv2.blur(mask, (blur_radius, blur_radius)) if background in ('transparent', 'average'): dest_img = np.dstack((dest_img, mask)) if background == 'average': # average_background = np.uint8(locator.average_points(images)) avg_background = perlin_background(images) avg_background[np.where( (avg_background == [0, 0, 0]).all(axis=2))] = [ 128, 128, 128 ] # black -> gray pixels in background dest_img = blender.overlay_image(dest_img, mask, avg_background) print('Averaged {} images'.format(num_images)) plt = plotter.Plotter(False, num_images=1, out_filename=out_filename) plt.save(dest_img)
def morph(src_img, src_points, dest_img, dest_points, video, width=500, height=600, num_frames=20, fps=10, out_frames=None, out_video=None, alpha=False, plot=False): """ Create a morph sequence from source to destination image :param out_video: :param src_img: ndarray source image :param src_img: source image array of x,y face points :param dest_img: ndarray destination image :param dest_img: destination image array of x,y face points :param video: facemorpher.videoer.Video object """ size = (height, width) stall_frames = np.clip(int(fps * 0.15), 1, fps) # Show first & last longer plt = plotter.Plotter(plot, num_images=num_frames, out_folder=out_frames) num_frames -= (stall_frames * 2) # No need to process src and dest image plt.plot_one(src_img) video.write(src_img, 1) # Produce morph frames! for percent in np.linspace(1, 0, num=num_frames): points = locator.weighted_average_points(src_points, dest_points, percent) src_face = warper.warp_image(src_img, src_points, points, size) end_face = warper.warp_image(dest_img, dest_points, points, size) average_face = blender.weighted_average(src_face, end_face, percent) average_face = alpha_image(average_face, points) if alpha else average_face average_bg = blender.weighted_average(src_img, dest_img, percent) img_over_bg(average_face, average_bg) plt.plot_one(average_bg, 'save') video.write(average_bg) plt.plot_one(dest_img) video.write(dest_img, stall_frames) plt.show()
def morph_ani( src_imgpaths, des_imgpath, num_pics, width=500, height=600, fps_in=24, slow_rate=5, out_frames=None, out_video=None, plot=False, ): num_frames = num_pics * slow_rate fps = fps_in * slow_rate video = videoer.Video(out_video, fps, width, height) plt = plotter.Plotter(plot, num_images=num_frames, out_folder=out_frames) dest_img, dest_points = load_image_points(des_imgpath, (height, width)) images_points_gen = load_valid_image_points(src_imgpaths, (height, width)) frameCount = 0 for src_img, src_points in images_points_gen: if frameCount == 0: p_face = src_img p_points = src_points avg_face0, avg_points0 = morph_one( src_img, src_points, dest_img, dest_points, 1 - float(frameCount) / (num_frames - 1), width, height) for i in range(0, slow_rate): avg_face, avg_points = morph_one(avg_face0, avg_points0, p_face, p_points, i / float(slow_rate - 1), width, height) mask = blender.mask_from_points(avg_face.shape[:2], avg_points) avg_face = np.dstack((avg_face, mask)) plt.plot_one(avg_face) plt.save(avg_face) video.write(avg_face) frameCount = frameCount + 1 p_face = avg_face0 p_points = avg_points0 video.end() plt.show()
def morph(src_img, src_points, dest_img, dest_points, video, width=500, height=600, num_frames=20, fps=10, out_frames=None, out_video=None, alpha=False, plot=False, obj=None, sessionid=None, result_type="zero"): """ Create a morph sequence from source to destination image :param src_img: ndarray source image :param src_img: source image array of x,y face points :param dest_img: ndarray destination image :param dest_img: destination image array of x,y face points :param video: facemorpher.videoer.Video object """ size = (height, width) stall_frames = np.clip(int(fps * 0.15), 1, fps) # Show first & last longer plt = plotter.Plotter(plot, num_images=num_frames, out_folder=out_frames) num_frames -= (stall_frames * 2) # No need to process src and dest image plt.plot_one(src_img) video.write(src_img, 1) # Produce morph frames! for percent in np.linspace(1, 0, num=num_frames): points = locator.weighted_average_points(src_points, dest_points, percent) src_face = warper.warp_image(src_img, src_points, points, size, result_type=result_type, bk_img=dest_img) end_face = warper.warp_image(dest_img, dest_points, points, size, result_type=result_type, bk_img=dest_img) # Check for a callback function if obj != None: debugMsg("morph calls mix_callback session={}".format(sessionid)) obj.mix_callback(sessionid, percent, points) else: debugMsg("morph has obj=None") average_face = blender.weighted_average(src_face, end_face, percent) average_face = alpha_image(average_face, points) if alpha else average_face plt.plot_one(average_face) plt.save(average_face) video.write(average_face) plt.plot_one(dest_img) video.write(dest_img, stall_frames) plt.show()