diff options
Diffstat (limited to 'megapixels')
19 files changed, 1470 insertions, 877 deletions
diff --git a/megapixels/app/processors/face_detector.py b/megapixels/app/processors/face_detector.py index 6bf27576..c0762564 100644 --- a/megapixels/app/processors/face_detector.py +++ b/megapixels/app/processors/face_detector.py @@ -1,3 +1,4 @@ +import sys import os from os.path import join from pathlib import Path @@ -30,8 +31,6 @@ class DetectorMTCNN: :returns list of BBox ''' bboxes = [] - #conf_thresh = self.conf_thresh if conf_thresh is None else conf_thresh - #pyramids = self.pyramids if pyramids is None else pyramids dnn_size = self.dnn_size if size is None else size im = im_utils.resize(im, width=dnn_size[0], height=dnn_size[1]) @@ -72,6 +71,9 @@ class DetectorDLIBCNN: import dlib self.log = logger_utils.Logger.getLogger() cuda_visible_devices = os.getenv('CUDA_VISIBLE_DEVICES', '') + if dlib.DLIB_USE_CUDA and gpu < 0: + self.log.error('dlib was compiled with CUDA but you selected CPU. Use GPU >= 0 if dlib.DLIB_USE_CUDA') + sys.exit() os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu) self.log.info('load model: {}'.format(cfg.DIR_MODELS_DLIB_CNN)) self.detector = dlib.cnn_face_detection_model_v1(cfg.DIR_MODELS_DLIB_CNN) diff --git a/megapixels/app/processors/face_landmarks.py b/megapixels/app/processors/face_landmarks.py index 8086ba1e..171fc666 100644 --- a/megapixels/app/processors/face_landmarks.py +++ b/megapixels/app/processors/face_landmarks.py @@ -83,8 +83,11 @@ class Dlib2D(Landmarks2D): self.log.info(f'loaded predictor model: {model}') def landmarks(self, im, bbox): - # Draw high-confidence faces - dim_wh = im.shape[:2][::-1] + '''Generates 68-pt landmarks using dlib predictor + :param im: (numpy.ndarray) BGR image + :param bbox: (app.models.BBox) dimensioned + :returns (list) of (int, int) for x,y values + ''' bbox = bbox.to_dlib() im_gray = cv.cvtColor(im, cv.COLOR_BGR2GRAY) points = [[p.x, p.y] for p in self.predictor(im_gray, bbox).parts()] @@ -168,8 +171,8 @@ class Landmarks3D: points_formatted[f'{d}{idx}'] = pt[j] return points_formatted - def normalize(self, points, dim): - return [np.array(p)/dim for p in points] # divides each point by w,h dim + # def normalize(self, points): + # '''TODO''' class FaceAlignment3D_68(Landmarks3D): @@ -182,13 +185,14 @@ class FaceAlignment3D_68(Landmarks3D): device = f'cuda:{gpu}' if gpu > -1 else 'cpu' self.fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._3D, device=device, flip_input=flip_input) - def landmarks(self, im, as_type=str): + def landmarks(self, im, rect): '''Calculates the 3D facial landmarks :param im: (numpy.ndarray) BGR image + :param rect: (list) of face (x1, y1, x2, y2) :returns (list) of 68 (int) (tuples) as (x,y, z) ''' # predict landmarks - points = self.fa.get_landmarks(im) # returns array of arrays of 68 3D pts/face + points = self.fa.get_landmarks(im, [rect]) # returns array of arrays of 68 3D pts/face # convert to data type points = [list(map(int, p)) for p in points[0]] return points
\ No newline at end of file diff --git a/megapixels/app/processors/face_landmarks_3d.py b/megapixels/app/processors/face_landmarks_3d.py index 470d263c..5a0d6097 100644 --- a/megapixels/app/processors/face_landmarks_3d.py +++ b/megapixels/app/processors/face_landmarks_3d.py @@ -26,14 +26,15 @@ class FaceAlignment3D(Landmarks3D): # Estimates 3D facial landmarks import face_alignment - def __init__(self, gpu=0, flip_input=False): + def __init__(self, gpu=0, flip_input=True): super().__init__() device = f'cuda:{gpu}' if gpu > -1 else 'cpu' self.fa = face_alignment.FaceAlignment(face_alignment.LandmarksType._3D, device=device, flip_input=flip_input) - def landmarks(self, im, as_type=str): + def landmarks(self, im, bbox, as_type=str): '''Calculates the 3D facial landmarks :param im: (numpy.ndarray) image + :param bbox: (BBox) dimensioned to real (int) sizes :param as_type: (str) or (list) type to return data ''' preds = self.fa.get_landmarks(im) diff --git a/megapixels/app/processors/face_pose.py b/megapixels/app/processors/face_pose.py index 8bc95f8d..5ac510ec 100644 --- a/megapixels/app/processors/face_pose.py +++ b/megapixels/app/processors/face_pose.py @@ -25,6 +25,12 @@ class FacePoseDLIB: def pose(self, landmarks, dim): + '''Returns face pose information + :param landmarks: (list) of 68 (int, int) xy tuples + :param dim: (tuple|list) of image (width, height) + :returns (dict) of pose attributes + ''' + # computes pose using 6 / 68 points from dlib face landmarks # based on learnopencv.com and # https://github.com/jerryhouuu/Face-Yaw-Roll-Pitch-from-Pose-Estimation-using-OpenCV/ diff --git a/megapixels/app/settings/app_cfg.py b/megapixels/app/settings/app_cfg.py index b13ff8ec..d206f40b 100644 --- a/megapixels/app/settings/app_cfg.py +++ b/megapixels/app/settings/app_cfg.py @@ -76,6 +76,7 @@ FP_FONT = join(DIR_ASSETS, 'font') # click chair settings # ----------------------------------------------------------------------------- DIR_COMMANDS_CV = 'commands/cv' +DIR_COMMANDS_VIZ = 'commands/visualize' DIR_COMMANDS_ADMIN = 'commands/admin' DIR_COMMANDS_DATASETS = 'commands/datasets' DIR_COMMANDS_FAISS = 'commands/faiss' diff --git a/megapixels/app/settings/types.py b/megapixels/app/settings/types.py index 50e395e0..1d77fdbd 100644 --- a/megapixels/app/settings/types.py +++ b/megapixels/app/settings/types.py @@ -64,9 +64,6 @@ class FaceLandmark2D_68(Enum): class FaceLandmark3D_68(Enum): FACE_ALIGNMENT = range(1) - -class FaceLandmark3D(Enum): - FACE_ALIGNMENT = range(1) class FaceEmotion(Enum): # Map these to text strings for web display diff --git a/megapixels/app/utils/display_utils.py b/megapixels/app/utils/display_utils.py index 58e2feec..7b74aa46 100644 --- a/megapixels/app/utils/display_utils.py +++ b/megapixels/app/utils/display_utils.py @@ -3,11 +3,11 @@ import sys import cv2 as cv -def handle_keyboard(): +def handle_keyboard(delay_amt=1): '''Used with cv.imshow('title', image) to wait for keyboard press ''' while True: - k = cv.waitKey(1) & 0xFF + k = cv.waitKey(delay_amt) & 0xFF if k == 27 or k == ord('q'): # ESC cv.destroyAllWindows() sys.exit() diff --git a/megapixels/app/utils/draw_utils.py b/megapixels/app/utils/draw_utils.py index f6d53609..47bb7978 100644 --- a/megapixels/app/utils/draw_utils.py +++ b/megapixels/app/utils/draw_utils.py @@ -49,17 +49,3 @@ def draw_degrees(im, pose_data, color=(0,255,0)): t = '{}: {:.2f}'.format(k, v) origin = (10, 30 + (25 * i)) cv.putText(im, t, origin, cv.FONT_HERSHEY_SIMPLEX, 0.5, clr, thickness=2, lineType=2) - - -# --------------------------------------------------------------------------- -# -# Matplotlib drawing functions -# -# --------------------------------------------------------------------------- - -def plot_landmarks3D(im, points, radius=3, color=(0,255,0), stroke_weight=2): - '''Draws facial landmarks, either 5pt or 68pt - ''' - for pt in points: - cv.circle(im, tuple(pt), radius, color, -1, cv.LINE_AA) - diff --git a/megapixels/app/utils/plot_utils.py b/megapixels/app/utils/plot_utils.py new file mode 100644 index 00000000..5bbb8ac2 --- /dev/null +++ b/megapixels/app/utils/plot_utils.py @@ -0,0 +1,149 @@ +import sys +from os.path import join +import time +import random +from pathlib import Path + +import numpy as np + +import matplotlib.pyplot as plt +import matplotlib.animation +from mpl_toolkits.mplot3d import Axes3D +from matplotlib import cbook +from matplotlib import cm +from matplotlib import animation + + + +# --------------------------------------------------------------------------- +# +# Matplotlib drawing functions +# +# --------------------------------------------------------------------------- + +# Generate random hex colors +def rhex(): + r = lambda: random.randint(0,255) + return '#%02X%02X%02X' % (r(), r(), r()) + + # line weight +def generate_3d_landmark_anim(lm, fp_out, num_frames=30, fps=12, dpi=72, size=(480,480), + stroke_weight=2, mark_size=10, mark_type='.', bg_clr=(0,0,0), transparent=False): + '''Generates animated 3D plot of face landmarks + ''' + + # convert opencv BGR numpy image to RGB + bg_clr_hex = '#%02x%02x%02x' % bg_clr + #mark_clr = '#%02x%02x%02x' % mark_clr + + # center x,y,z + xmm = (np.min(lm[:,0]),np.max(lm[:,0])) + ymm = (np.min(lm[:,1]),np.max(lm[:,1])) + zmm = (np.min(lm[:,2]),np.max(lm[:,2])) + + # make copy of landmarks + lm_orig = lm.copy() + xmm = (np.min(lm_orig[:,0]),np.max(lm_orig[:,0])) + ymm = (np.min(lm_orig[:,1]),np.max(lm_orig[:,1])) + zmm = (np.min(lm_orig[:,2]),np.max(lm_orig[:,2])) + + # swap the y and z components to improve 3d rotation angles for matplotlib + lm = np.zeros_like(lm_orig).astype(np.uint8) + for i,p in enumerate(lm_orig): + x,y,z = p + lm[i] = np.array([x - xmm[0], z - zmm[0], y - ymm[0]]) + + # Create plot + figsize = (size[0]/dpi, size[1]/dpi ) + fig = plt.figure(figsize=figsize, dpi=dpi) # frameon=False + fig.tight_layout() + # remove whitespace in matplotlib + fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=None, hspace=None) + ax = fig.add_subplot(111, projection='3d') + ax.set_facecolor(bg_clr_hex) # background color + + xscale, yscale, zscale = (1.2, 1.0, 1.0) + + # scatter plot the dots + + # jaw line + mark_clr = '#%02x%02x%02x' % (0,255,0) # green + ax.plot3D(lm[:17,0]*1.2,lm[:17,1], lm[:17,2], + marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # stage-right eyebrow + mark_clr = '#%02x%02x%02x' % (255,0,0) # green + ax.plot3D(lm[17:22,0]*1.2,lm[17:22,1],lm[17:22,2], + marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # stage-left eyebrow + mark_clr = '#%02x%02x%02x' % (255,255,0) # yellow + ax.plot3D(lm[22:27,0]*1.2,lm[22:27,1],lm[22:27,2], + marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # nose ridge + mark_clr = '#%02x%02x%02x' % (0,0,255) # blue + ax.plot3D(lm[27:31,0]*1.2,lm[27:31,1],lm[27:31,2], + marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # nose-bottom + mark_clr = '#%02x%02x%02x' % (255,0,255) # magenta + ax.plot3D(lm[31:36,0]*1.2,lm[31:36,1],lm[31:36,2], + marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # stage-left eye + mark_clr = '#%02x%02x%02x' % (0,255,255) # cyan + px, py, pz = lm[36:42,0]*1.2,lm[36:42,1],lm[36:42,2] + px = np.append(px, lm[36,0]*1.2) + py = np.append(py, lm[36,1]) + pz = np.append(pz, lm[36,2]) + ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # stage-right eye + mark_clr = '#%02x%02x%02x' % (255,255,255) # white + px, py, pz = lm[42:48,0]*1.2,lm[42:48,1],lm[42:48,2] + px = np.append(px, lm[42,0]*1.2) + py = np.append(py, lm[42,1]) + pz = np.append(pz, lm[42,2]) + ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr,linewidth=stroke_weight) + + # mouth + mark_clr = '#%02x%02x%02x' % (255,125,0) # orange? + px, py, pz = lm[48:,0]*1.2,lm[48:,1],lm[48:,2] + px = np.append(px, lm[48,0]*1.2) + py = np.append(py, lm[48,1]) + pz = np.append(pz, lm[48,2]) + ax.plot3D(px, py, pz, marker=mark_type, markersize=mark_size, color=mark_clr, linewidth=stroke_weight) + + #rh = '#00ff00' # edge color + #ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=35, edgecolor=rh) + #ax.scatter(lm[:,0]*xscale,lm[:,1]*yscale,lm[:,2]*zscale, c=rh, alpha=1.0, s=1) + + # center center x,y,z points + cx = ((xmm[0] - xmm[1]) // 2) + xmm[1] + cy = ((ymm[1] - ymm[0]) // 2) + ymm[0] + cz = ((zmm[1] - zmm[0]) // 2) + zmm[0] + + # remove ticks + ax.set_xticks([]) + ax.set_yticks([]) + ax.set_zticks([]) + + # remove axis + ax.set_frame_on(False) + ax.set_axis_off() + + # set initial plot view + ax.view_init(elev=120., azim=70.) + + # rotation increments: from 0 to 360 in num_frames + phi = np.linspace(0, 2*np.pi, num_frames) + + # animation instruction + def update(phi): + ax.view_init(180,phi*180./np.pi) + + ani = matplotlib.animation.FuncAnimation(fig, update, frames=phi) + + savefig_kwargs = {'pad_inches': 0, 'transparent': transparent} + ani.save(fp_out, writer='imagemagick', fps=fps, savefig_kwargs=savefig_kwargs)
\ No newline at end of file diff --git a/megapixels/cli_visualize.py b/megapixels/cli_visualize.py new file mode 100644 index 00000000..0e80af53 --- /dev/null +++ b/megapixels/cli_visualize.py @@ -0,0 +1,36 @@ +# -------------------------------------------------------- +# add/edit commands in commands/datasets directory +# -------------------------------------------------------- + +import click + +from app.settings import app_cfg as cfg +from app.utils import logger_utils +from app.models.click_factory import ClickSimple + +# click cli factory +cc = ClickSimple.create(cfg.DIR_COMMANDS_VIZ) + +# -------------------------------------------------------- +# CLI +# -------------------------------------------------------- +@click.group(cls=cc, chain=False) +@click.option('-v', '--verbose', 'verbosity', count=True, default=4, + show_default=True, + help='Verbosity: -v DEBUG, -vv INFO, -vvv WARN, -vvvv ERROR, -vvvvv CRITICAL') +@click.pass_context +def cli(ctx, **kwargs): + """\033[1m\033[94mMegaPixels: Dataset Image Scripts\033[0m + """ + ctx.opts = {} + # init logger + logger_utils.Logger.create(verbosity=kwargs['verbosity']) + + + +# -------------------------------------------------------- +# Entrypoint +# -------------------------------------------------------- +if __name__ == '__main__': + cli() + diff --git a/megapixels/commands/cv/face_landmark_3d_68.py b/megapixels/commands/cv/face_landmark_3d_68.py index 56e60cda..a2d14d72 100644 --- a/megapixels/commands/cv/face_landmark_3d_68.py +++ b/megapixels/commands/cv/face_landmark_3d_68.py @@ -57,6 +57,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_dir_media, opt_data_store, opt_dataset, import pandas as pd from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils from app.processors import face_landmarks from app.models.data_store import DataStore from app.models.bbox import BBox @@ -65,7 +66,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_dir_media, opt_data_store, opt_dataset, # init here log = logger_utils.Logger.getLogger() - log.warn('3D landmark points are normalized in a (200, 200, 200) XYZ space') + log.warn('not normalizing points') # init filepaths data_store = DataStore(opt_data_store, opt_dataset) # set file output path @@ -76,7 +77,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_dir_media, opt_data_store, opt_dataset, return # init face landmark processors - if opt_detector_type == types.FaceLandmark2D_5.FACE_ALIGNMENT: + if opt_detector_type == types.FaceLandmark3D_68.FACE_ALIGNMENT: # use FaceAlignment 68 point 3D detector landmark_detector = face_landmarks.FaceAlignment3D_68() else: @@ -122,16 +123,18 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_dir_media, opt_data_store, opt_dataset, # get landmark points points = landmark_detector.landmarks(im_resized, bbox) # NB can't really normalize these points, but are normalized against 3D space - points_norm = landmark_detector.normalize(points, dim) # normalized using 200 + #points_norm = landmark_detector.normalize(points, dim) # normalized using 200 points_flattenend = landmark_detector.flatten(points) # display to screen if optioned if opt_display: - draw_utils.draw_landmarks2D(im_resized, points) + draw_utils.draw_landmarks3D(im_resized, points) draw_utils.draw_bbox(im_resized, bbox) cv.imshow('', im_resized) display_utils.handle_keyboard() + #plot_utils.generate_3d_landmark_anim(points, '/home/adam/Downloads/3d.gif') + results.append(points_flattenend) # create DataFrame and save to CSV diff --git a/megapixels/commands/demo/3d_landmark_anim.py b/megapixels/commands/demo/3d_landmark_anim.py new file mode 100644 index 00000000..22e09297 --- /dev/null +++ b/megapixels/commands/demo/3d_landmark_anim.py @@ -0,0 +1,219 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='GIF output path') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('--gif-size', 'opt_gif_size', + type=(int, int), default=(480, 480), + help='GIF output size') +@click.option('--gif-frames', 'opt_gif_frames', default=15, + help='GIF frames') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_gif_frames, + opt_size, opt_gif_size, opt_force, opt_display): + """Generates 3D landmark animations from CSV files""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + from tqdm import tqdm + import numpy as np + import pandas as pd + import cv2 as cv + import dlib + from PIL import Image + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector, face_landmarks + from app.models.data_store import DataStore + + # TOOD add selective testing + opt_run_pose = True + opt_run_2d_68 = True + opt_run_3d_68 = True + opt_run_3d_68 = True + + + # ------------------------------------------------- + # init here + + + log = logger_utils.Logger.getLogger() + + # load image + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + log.info('detecting face...') + st = time.time() + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + else: + log.info(f'Detected face in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # detect 3D landmarks + + log.info('loading 3D landmark generator files...') + landmark_detector_3d_68 = face_landmarks.FaceAlignment3D_68(gpu=opt_gpu) # -1 for CPU + log.info('generating 3D landmarks...') + st = time.time() + points_3d_68 = landmark_detector_3d_68.landmarks(im_resized, bbox_dim.to_xyxy()) + log.info(f'generated 3D landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 3D GIF animation + + log.info('generating 3D animation...') + if not opt_fp_out: + fpp_im = Path(opt_fp_in) + fp_out = join(fpp_im.parent, f'{fpp_im.stem}_anim.gif') + else: + fp_out = opt_fp_out + st = time.time() + plot_utils.generate_3d_landmark_anim(np.array(points_3d_68), fp_out, + size=opt_gif_size, num_frames=opt_gif_frames) + log.info(f'Generated animation in {(time.time() - st):.2f}s') + log.info(f'Saved to: {fp_out}') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate face vectors, only to test if feature extraction works + + log.info('initialize face recognition model...') + from app.processors import face_recognition + face_rec = face_recognition.RecognitionDLIB() + st = time.time() + log.info('generating face vector...') + vec = face_rec.vec(im_resized, bbox_dim) + log.info(f'generated face vector in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 68 point landmarks using dlib + + log.info('initializing face landmarks 68 dlib...') + from app.processors import face_landmarks + landmark_detector_2d_68 = face_landmarks.Dlib2D_68() + log.info('generating 2D 68PT landmarks...') + st = time.time() + points_2d_68 = landmark_detector_2d_68.landmarks(im_resized, bbox_dim) + log.info(f'generated 2D 68PT face landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate pose from 68 point 2D landmarks + + if opt_run_pose: + log.info('initialize pose...') + from app.processors import face_pose + pose_detector = face_pose.FacePoseDLIB() + log.info('generating pose...') + st = time.time() + pose_data = pose_detector.pose(points_2d_68, dim) + log.info(f'generated pose {(time.time() - st):.2f}s') + log.info('') + + + # x + + + + # display + if opt_display: + + # draw bbox + + # draw 3d landmarks + im_landmarks_3d_68 = im_resized.copy() + draw_utils.draw_landmarks3D(im_landmarks_3d_68, points_3d_68) + draw_utils.draw_bbox(im_landmarks_3d_68, bbox_dim) + + # draw 2d landmarks + im_landmarks_2d_68 = im_resized.copy() + draw_utils.draw_landmarks2D(im_landmarks_2d_68, points_2d_68) + draw_utils.draw_bbox(im_landmarks_2d_68, bbox_dim) + + # draw pose + if opt_run_pose: + im_pose = im_resized.copy() + draw_utils.draw_pose(im_pose, pose_data['point_nose'], pose_data['points']) + draw_utils.draw_degrees(im_pose, pose_data) + + # draw animated GIF + im = Image.open(opt_fp_out) + im_frames = [] + duration = im.info['duration'] + try: + while True: + im.seek(len(im_frames)) + mypalette = im.getpalette() + im.putpalette(mypalette) + im_jpg = Image.new("RGB", im.size) + im_jpg.paste(im) + im_np = im_utils.pil2np(im_jpg.copy()) + im_frames.append(im_np) + except EOFError: + pass # end of GIF sequence + + n_frames = len(im_frames) + frame_number = 0 + + while True: + # show all images here + cv.imshow('Original', im_resized) + cv.imshow('2D 68PT Landmarks', im_landmarks_2d_68) + cv.imshow('3D 68PT Landmarks', im_landmarks_3d_68) + cv.imshow('Pose', im_pose) + cv.imshow('3D 68pt GIF', im_frames[frame_number]) + frame_number = (frame_number + 1) % n_frames + k = cv.waitKey(duration) & 0xFF + if k == 27 or k == ord('q'): # ESC + cv.destroyAllWindows() + sys.exit() + elif k != 255: + # any key to continue + break
\ No newline at end of file diff --git a/megapixels/commands/demo/face_detection.py b/megapixels/commands/demo/face_detection.py new file mode 100644 index 00000000..fb23704b --- /dev/null +++ b/megapixels/commands/demo/face_detection.py @@ -0,0 +1,128 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='GIF output path') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): + """Face detector demo""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + from tqdm import tqdm + import numpy as np + import pandas as pd + import cv2 as cv + import dlib + from PIL import Image + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector, face_landmarks + from app.models.data_store import DataStore + + + log = logger_utils.Logger.getLogger() + + + # ------------------------------------------------- + # load image + + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + + + # ---------------------------------------------------------------------------- + # generate 68 point landmarks using dlib + + from app.processors import face_landmarks + landmark_detector_2d_68 = face_landmarks.Dlib2D_68() + points_2d_68 = landmark_detector_2d_68.landmarks(im_resized, bbox_dim) + + + # ---------------------------------------------------------------------------- + # generate pose from 68 point 2D landmarks + + from app.processors import face_pose + pose_detector = face_pose.FacePoseDLIB() + pose_data = pose_detector.pose(points_2d_68, dim) + + # ---------------------------------------------------------------------------- + # output + + log.info(f'Face coords: {bbox_dim} face') + log.info(f'pitch: {pose_data["pitch"]}, roll: {pose_data["roll"]}, yaw: {pose_data["yaw"]}') + + + # ---------------------------------------------------------------------------- + # draw + + # draw 2d landmarks + im_landmarks_2d_68 = im_resized.copy() + draw_utils.draw_landmarks2D(im_landmarks_2d_68, points_2d_68) + draw_utils.draw_bbox(im_landmarks_2d_68, bbox_dim) + + # draw pose + im_pose = im_resized.copy() + draw_utils.draw_pose(im_pose, pose_data['point_nose'], pose_data['points']) + draw_utils.draw_degrees(im_pose, pose_data) + + + # ---------------------------------------------------------------------------- + # save + + if opt_fp_out: + # save pose only + cv.imwrite(opt_fp_out, im_pose) + + + # ---------------------------------------------------------------------------- + # display + + if opt_display: + + + # show all images here + cv.imshow('Original', im_resized) + cv.imshow('2D 68PT Landmarks', im_landmarks_2d_68) + cv.imshow('Pose', im_pose) + display_utils.handle_keyboard()
\ No newline at end of file diff --git a/megapixels/commands/demo/face_landmarks_2d.py b/megapixels/commands/demo/face_landmarks_2d.py new file mode 100644 index 00000000..22e09297 --- /dev/null +++ b/megapixels/commands/demo/face_landmarks_2d.py @@ -0,0 +1,219 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='GIF output path') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('--gif-size', 'opt_gif_size', + type=(int, int), default=(480, 480), + help='GIF output size') +@click.option('--gif-frames', 'opt_gif_frames', default=15, + help='GIF frames') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_gif_frames, + opt_size, opt_gif_size, opt_force, opt_display): + """Generates 3D landmark animations from CSV files""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + from tqdm import tqdm + import numpy as np + import pandas as pd + import cv2 as cv + import dlib + from PIL import Image + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector, face_landmarks + from app.models.data_store import DataStore + + # TOOD add selective testing + opt_run_pose = True + opt_run_2d_68 = True + opt_run_3d_68 = True + opt_run_3d_68 = True + + + # ------------------------------------------------- + # init here + + + log = logger_utils.Logger.getLogger() + + # load image + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + log.info('detecting face...') + st = time.time() + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + else: + log.info(f'Detected face in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # detect 3D landmarks + + log.info('loading 3D landmark generator files...') + landmark_detector_3d_68 = face_landmarks.FaceAlignment3D_68(gpu=opt_gpu) # -1 for CPU + log.info('generating 3D landmarks...') + st = time.time() + points_3d_68 = landmark_detector_3d_68.landmarks(im_resized, bbox_dim.to_xyxy()) + log.info(f'generated 3D landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 3D GIF animation + + log.info('generating 3D animation...') + if not opt_fp_out: + fpp_im = Path(opt_fp_in) + fp_out = join(fpp_im.parent, f'{fpp_im.stem}_anim.gif') + else: + fp_out = opt_fp_out + st = time.time() + plot_utils.generate_3d_landmark_anim(np.array(points_3d_68), fp_out, + size=opt_gif_size, num_frames=opt_gif_frames) + log.info(f'Generated animation in {(time.time() - st):.2f}s') + log.info(f'Saved to: {fp_out}') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate face vectors, only to test if feature extraction works + + log.info('initialize face recognition model...') + from app.processors import face_recognition + face_rec = face_recognition.RecognitionDLIB() + st = time.time() + log.info('generating face vector...') + vec = face_rec.vec(im_resized, bbox_dim) + log.info(f'generated face vector in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 68 point landmarks using dlib + + log.info('initializing face landmarks 68 dlib...') + from app.processors import face_landmarks + landmark_detector_2d_68 = face_landmarks.Dlib2D_68() + log.info('generating 2D 68PT landmarks...') + st = time.time() + points_2d_68 = landmark_detector_2d_68.landmarks(im_resized, bbox_dim) + log.info(f'generated 2D 68PT face landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate pose from 68 point 2D landmarks + + if opt_run_pose: + log.info('initialize pose...') + from app.processors import face_pose + pose_detector = face_pose.FacePoseDLIB() + log.info('generating pose...') + st = time.time() + pose_data = pose_detector.pose(points_2d_68, dim) + log.info(f'generated pose {(time.time() - st):.2f}s') + log.info('') + + + # x + + + + # display + if opt_display: + + # draw bbox + + # draw 3d landmarks + im_landmarks_3d_68 = im_resized.copy() + draw_utils.draw_landmarks3D(im_landmarks_3d_68, points_3d_68) + draw_utils.draw_bbox(im_landmarks_3d_68, bbox_dim) + + # draw 2d landmarks + im_landmarks_2d_68 = im_resized.copy() + draw_utils.draw_landmarks2D(im_landmarks_2d_68, points_2d_68) + draw_utils.draw_bbox(im_landmarks_2d_68, bbox_dim) + + # draw pose + if opt_run_pose: + im_pose = im_resized.copy() + draw_utils.draw_pose(im_pose, pose_data['point_nose'], pose_data['points']) + draw_utils.draw_degrees(im_pose, pose_data) + + # draw animated GIF + im = Image.open(opt_fp_out) + im_frames = [] + duration = im.info['duration'] + try: + while True: + im.seek(len(im_frames)) + mypalette = im.getpalette() + im.putpalette(mypalette) + im_jpg = Image.new("RGB", im.size) + im_jpg.paste(im) + im_np = im_utils.pil2np(im_jpg.copy()) + im_frames.append(im_np) + except EOFError: + pass # end of GIF sequence + + n_frames = len(im_frames) + frame_number = 0 + + while True: + # show all images here + cv.imshow('Original', im_resized) + cv.imshow('2D 68PT Landmarks', im_landmarks_2d_68) + cv.imshow('3D 68PT Landmarks', im_landmarks_3d_68) + cv.imshow('Pose', im_pose) + cv.imshow('3D 68pt GIF', im_frames[frame_number]) + frame_number = (frame_number + 1) % n_frames + k = cv.waitKey(duration) & 0xFF + if k == 27 or k == ord('q'): # ESC + cv.destroyAllWindows() + sys.exit() + elif k != 255: + # any key to continue + break
\ No newline at end of file diff --git a/megapixels/commands/demo/face_landmarks_3d.py b/megapixels/commands/demo/face_landmarks_3d.py new file mode 100644 index 00000000..22e09297 --- /dev/null +++ b/megapixels/commands/demo/face_landmarks_3d.py @@ -0,0 +1,219 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='GIF output path') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('--gif-size', 'opt_gif_size', + type=(int, int), default=(480, 480), + help='GIF output size') +@click.option('--gif-frames', 'opt_gif_frames', default=15, + help='GIF frames') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_gif_frames, + opt_size, opt_gif_size, opt_force, opt_display): + """Generates 3D landmark animations from CSV files""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + from tqdm import tqdm + import numpy as np + import pandas as pd + import cv2 as cv + import dlib + from PIL import Image + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector, face_landmarks + from app.models.data_store import DataStore + + # TOOD add selective testing + opt_run_pose = True + opt_run_2d_68 = True + opt_run_3d_68 = True + opt_run_3d_68 = True + + + # ------------------------------------------------- + # init here + + + log = logger_utils.Logger.getLogger() + + # load image + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + log.info('detecting face...') + st = time.time() + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + else: + log.info(f'Detected face in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # detect 3D landmarks + + log.info('loading 3D landmark generator files...') + landmark_detector_3d_68 = face_landmarks.FaceAlignment3D_68(gpu=opt_gpu) # -1 for CPU + log.info('generating 3D landmarks...') + st = time.time() + points_3d_68 = landmark_detector_3d_68.landmarks(im_resized, bbox_dim.to_xyxy()) + log.info(f'generated 3D landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 3D GIF animation + + log.info('generating 3D animation...') + if not opt_fp_out: + fpp_im = Path(opt_fp_in) + fp_out = join(fpp_im.parent, f'{fpp_im.stem}_anim.gif') + else: + fp_out = opt_fp_out + st = time.time() + plot_utils.generate_3d_landmark_anim(np.array(points_3d_68), fp_out, + size=opt_gif_size, num_frames=opt_gif_frames) + log.info(f'Generated animation in {(time.time() - st):.2f}s') + log.info(f'Saved to: {fp_out}') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate face vectors, only to test if feature extraction works + + log.info('initialize face recognition model...') + from app.processors import face_recognition + face_rec = face_recognition.RecognitionDLIB() + st = time.time() + log.info('generating face vector...') + vec = face_rec.vec(im_resized, bbox_dim) + log.info(f'generated face vector in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate 68 point landmarks using dlib + + log.info('initializing face landmarks 68 dlib...') + from app.processors import face_landmarks + landmark_detector_2d_68 = face_landmarks.Dlib2D_68() + log.info('generating 2D 68PT landmarks...') + st = time.time() + points_2d_68 = landmark_detector_2d_68.landmarks(im_resized, bbox_dim) + log.info(f'generated 2D 68PT face landmarks in {(time.time() - st):.2f}s') + log.info('') + + + # ---------------------------------------------------------------------------- + # generate pose from 68 point 2D landmarks + + if opt_run_pose: + log.info('initialize pose...') + from app.processors import face_pose + pose_detector = face_pose.FacePoseDLIB() + log.info('generating pose...') + st = time.time() + pose_data = pose_detector.pose(points_2d_68, dim) + log.info(f'generated pose {(time.time() - st):.2f}s') + log.info('') + + + # x + + + + # display + if opt_display: + + # draw bbox + + # draw 3d landmarks + im_landmarks_3d_68 = im_resized.copy() + draw_utils.draw_landmarks3D(im_landmarks_3d_68, points_3d_68) + draw_utils.draw_bbox(im_landmarks_3d_68, bbox_dim) + + # draw 2d landmarks + im_landmarks_2d_68 = im_resized.copy() + draw_utils.draw_landmarks2D(im_landmarks_2d_68, points_2d_68) + draw_utils.draw_bbox(im_landmarks_2d_68, bbox_dim) + + # draw pose + if opt_run_pose: + im_pose = im_resized.copy() + draw_utils.draw_pose(im_pose, pose_data['point_nose'], pose_data['points']) + draw_utils.draw_degrees(im_pose, pose_data) + + # draw animated GIF + im = Image.open(opt_fp_out) + im_frames = [] + duration = im.info['duration'] + try: + while True: + im.seek(len(im_frames)) + mypalette = im.getpalette() + im.putpalette(mypalette) + im_jpg = Image.new("RGB", im.size) + im_jpg.paste(im) + im_np = im_utils.pil2np(im_jpg.copy()) + im_frames.append(im_np) + except EOFError: + pass # end of GIF sequence + + n_frames = len(im_frames) + frame_number = 0 + + while True: + # show all images here + cv.imshow('Original', im_resized) + cv.imshow('2D 68PT Landmarks', im_landmarks_2d_68) + cv.imshow('3D 68PT Landmarks', im_landmarks_3d_68) + cv.imshow('Pose', im_pose) + cv.imshow('3D 68pt GIF', im_frames[frame_number]) + frame_number = (frame_number + 1) % n_frames + k = cv.waitKey(duration) & 0xFF + if k == 27 or k == ord('q'): # ESC + cv.destroyAllWindows() + sys.exit() + elif k != 255: + # any key to continue + break
\ No newline at end of file diff --git a/megapixels/commands/demo/face_pose.py b/megapixels/commands/demo/face_pose.py new file mode 100644 index 00000000..3918adac --- /dev/null +++ b/megapixels/commands/demo/face_pose.py @@ -0,0 +1,128 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='GIF output path') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): + """Face pose demo""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + from tqdm import tqdm + import numpy as np + import pandas as pd + import cv2 as cv + import dlib + from PIL import Image + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector, face_landmarks + from app.models.data_store import DataStore + + + log = logger_utils.Logger.getLogger() + + + # ------------------------------------------------- + # load image + + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + + + # ---------------------------------------------------------------------------- + # generate 68 point landmarks using dlib + + from app.processors import face_landmarks + landmark_detector_2d_68 = face_landmarks.Dlib2D_68() + points_2d_68 = landmark_detector_2d_68.landmarks(im_resized, bbox_dim) + + + # ---------------------------------------------------------------------------- + # generate pose from 68 point 2D landmarks + + from app.processors import face_pose + pose_detector = face_pose.FacePoseDLIB() + pose_data = pose_detector.pose(points_2d_68, dim) + + # ---------------------------------------------------------------------------- + # output + + log.info(f'Face coords: {bbox_dim} face') + log.info(f'pitch: {pose_data["pitch"]}, roll: {pose_data["roll"]}, yaw: {pose_data["yaw"]}') + + + # ---------------------------------------------------------------------------- + # draw + + # draw 2d landmarks + im_landmarks_2d_68 = im_resized.copy() + draw_utils.draw_landmarks2D(im_landmarks_2d_68, points_2d_68) + draw_utils.draw_bbox(im_landmarks_2d_68, bbox_dim) + + # draw pose + im_pose = im_resized.copy() + draw_utils.draw_pose(im_pose, pose_data['point_nose'], pose_data['points']) + draw_utils.draw_degrees(im_pose, pose_data) + + + # ---------------------------------------------------------------------------- + # save + + if opt_fp_out: + # save pose only + cv.imwrite(opt_fp_out, im_pose) + + + # ---------------------------------------------------------------------------- + # display + + if opt_display: + + + # show all images here + cv.imshow('Original', im_resized) + cv.imshow('2D 68PT Landmarks', im_landmarks_2d_68) + cv.imshow('Pose', im_pose) + display_utils.handle_keyboard()
\ No newline at end of file diff --git a/megapixels/commands/demo/face_vector.py b/megapixels/commands/demo/face_vector.py new file mode 100644 index 00000000..1104f923 --- /dev/null +++ b/megapixels/commands/demo/face_vector.py @@ -0,0 +1,79 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, required=True, + help='Image filepath') +@click.option('--size', 'opt_size', + type=(int, int), default=(300, 300), + help='Output image size') +@click.option('-g', '--gpu', 'opt_gpu', default=0, + help='GPU index') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.pass_context +def cli(ctx, opt_fp_in, opt_gpu, opt_size, opt_display): + """Demo generating face vector""" + + import sys + import os + from os.path import join + from pathlib import Path + import time + + import numpy as np + import cv2 as cv + import dlib # NB: keep a reference in main file if using dlib detector processors + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector + from app.models.data_store import DataStore + + # ------------------------------------------------- + # init here + + log = logger_utils.Logger.getLogger() + + # ---------------------------------------------------------------------------- + # load image + + im = cv.imread(opt_fp_in) + im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) + + + # ---------------------------------------------------------------------------- + # detect face + + face_detector = face_detector.DetectorDLIBCNN(gpu=opt_gpu) # -1 for CPU + bboxes = face_detector.detect(im_resized, largest=True) + bbox = bboxes[0] + dim = im_resized.shape[:2][::-1] + bbox_dim = bbox.to_dim(dim) + if not bbox: + log.error('no face detected') + return + + + # ---------------------------------------------------------------------------- + # generate face vectors, only to test if feature extraction works + + from app.processors import face_recognition + face_rec = face_recognition.RecognitionDLIB() + vec = face_rec.vec(im_resized, bbox_dim) + log.info(f'generated vector. showing vec[0:10]:') + log.info(f'\n{vec[0:10]}') + + if opt_display: + draw_utils.draw_bbox(im_resized, bbox_dim) + cv.imshow('Original', im_resized) + display_utils.handle_keyboard()
\ No newline at end of file diff --git a/megapixels/commands/visualize/plot_3d_landmarks.py b/megapixels/commands/visualize/plot_3d_landmarks.py new file mode 100644 index 00000000..a0f9e555 --- /dev/null +++ b/megapixels/commands/visualize/plot_3d_landmarks.py @@ -0,0 +1,89 @@ +""" +Crop images to prepare for training +""" + +import click +# from PIL import Image, ImageOps, ImageFilter, ImageDraw + +from app.settings import types +from app.utils import click_utils +from app.settings import app_cfg as cfg + +color_filters = {'color': 1, 'gray': 2, 'all': 3} + +@click.command() +@click.option('-i', '--input', 'opt_fp_in', default=None, + help='Override enum input filename CSV') +@click.option('-o', '--output', 'opt_fp_out', default=None, + help='Override enum output filename CSV') +@click.option('-m', '--media', 'opt_dir_media', default=None, + help='Override enum media directory') +@click.option('--store', 'opt_data_store', + type=cfg.DataStoreVar, + default=click_utils.get_default(types.DataStore.HDD), + show_default=True, + help=click_utils.show_help(types.Dataset)) +@click.option('--dataset', 'opt_dataset', + type=cfg.DatasetVar, + required=True, + show_default=True, + help=click_utils.show_help(types.Dataset)) +@click.option('--size', 'opt_size', + type=(int, int), default=(480, 480), + help='Output image size') +@click.option('--slice', 'opt_slice', type=(int, int), default=(None, None), + help='Slice list of files') +@click.option('--display/--no-display', 'opt_display', is_flag=True, default=False, + help='Display detections to debug') +@click.option('-f', '--force', 'opt_force', is_flag=True, + help='Force overwrite file') +@click.pass_context +def cli(ctx, opt_fp_in, opt_dir_media, opt_fp_out, opt_data_store, opt_dataset, + opt_size, opt_slice, opt_display, opt_force): + """Generates 3D landmark animations from CSV files""" + + import sys + import os + from os.path import join + from pathlib import Path + + from tqdm import tqdm + import numpy as np + import pandas as pd + import matplotlib.pyplot as plt + + from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils + from app.utils import plot_utils + from app.processors import face_detector + from app.models.data_store import DataStore + + # ------------------------------------------------- + # init here + + log = logger_utils.Logger.getLogger() + + # set storage location + data_store = DataStore(opt_data_store, opt_dataset) + # load file records + fp_record = data_store.metadata(types.Metadata.FILE_RECORD) # file_record.csv + df_records = pd.read_csv(fp_record).set_index('index') + # load ROI data + fp_roi = data_store.metadata(types.Metadata.FACE_ROI) # face_roi.csv + df_rois = pd.read_csv(fp_roi).set_index('index') + fp_landmark_3d = data_store.metadata(types.Metadata.FACE_LANDMARK_3D_68) # face_landmark_3d_68.csv + df_landmarks_3d = pd.read_csv(fp_landmark_3d).set_index('index') + if opt_slice: + df_landmarks_3d = df_landmarks_3d[opt_slice[0]:opt_slice[1]] # slice if you want + log.debug('processing {:,} groups'.format(len(df_landmarks_3d))) + + # get filepath out + #fp_out = data_store.metadata(types.Metadata.FACE_ROI) if opt_fp_out is None else opt_fp_out + fp_out = '/home/adam/Downloads/3d.gif' + + + for roi_index, df_3d in tqdm(df_landmarks_3d.iterrows(), total=len(df_landmarks_3d)): + log.debug(f'roi_index: {roi_index}') + # unflatten points + points_3d = np.array([(df_3d[f'x{i}'], df_3d[f'y{i}'], df_3d[f'z{i}']) for i in range(1, 68)]) + plot_utils.generate_3d_landmark_anim(points_3d, fp_out, size=(300,300)) + break
\ No newline at end of file diff --git a/megapixels/notebooks/face_analysis/3d_face_plot.ipynb b/megapixels/notebooks/face_analysis/3d_face_plot.ipynb index f136015f..591b8706 100644 --- a/megapixels/notebooks/face_analysis/3d_face_plot.ipynb +++ b/megapixels/notebooks/face_analysis/3d_face_plot.ipynb @@ -11,18 +11,9 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -53,12 +44,14 @@ "from skimage import io\n", "from tqdm import tqdm_notebook as tqdm\n", "from IPython.display import clear_output\n", - "from pathlib import Path" + "from pathlib import Path\n", + "\n", + "sys.path.append('/work/megapixels_dev/megapixels/')" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -70,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -81,36 +74,17 @@ }, { "cell_type": "code", - "execution_count": 276, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "<matplotlib.image.AxesImage at 0x7fa3cc186c50>" - ] - }, - "execution_count": 276, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "fp_im = '/data_store_hdd/datasets/people/vgg_face2/media/original/test/n000009/0012_01.jpg'\n", - "im = cv.imread(fp_im)\n", - "plt.imshow(im)" + "im = cv.imread(fp_im)" ] }, { "cell_type": "code", - "execution_count": 287, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 288, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -164,810 +138,107 @@ }, { "cell_type": "code", - "execution_count": 367, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from app.utils import im_utils" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "im = cv.imread(fp_im)\n", + "im_resized = im_utils.resize(im, width=300, height=300)\n", + "im_rgb = cv.cvtColor(im, cv.COLOR_BGR2RGB)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#import dlib\n", + "from app.processors import face_detector" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#face_detector = face_detector.DetectorDLIBCNN(gpu=0) # -1 for CPU\n", + "face_detector = face_detector.DetectorCVDNN()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, "metadata": {}, "outputs": [ { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "window.mpl = {};\n", - "\n", - "\n", - "mpl.get_websocket_type = function() {\n", - " if (typeof(WebSocket) !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof(MozWebSocket) !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert('Your browser does not have WebSocket support.' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.');\n", - " };\n", - "}\n", - "\n", - "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = (this.ws.binaryType != undefined);\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById(\"mpl-warnings\");\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent = (\n", - " \"This browser does not support binary websocket messages. \" +\n", - " \"Performance may be slow.\");\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = $('<div/>');\n", - " this._root_extra_style(this.root)\n", - " this.root.attr('style', 'display: inline-block');\n", - "\n", - " $(parent_element).append(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", - " fig.send_message(\"send_image_mode\", {});\n", - " if (mpl.ratio != 1) {\n", - " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", - " }\n", - " fig.send_message(\"refresh\", {});\n", - " }\n", - "\n", - " this.imageObj.onload = function() {\n", - " if (fig.image_mode == 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function() {\n", - " fig.ws.close();\n", - " }\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "}\n", - "\n", - "mpl.figure.prototype._init_header = function() {\n", - " var titlebar = $(\n", - " '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n", - " 'ui-helper-clearfix\"/>');\n", - " var titletext = $(\n", - " '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n", - " 'text-align: center; padding: 3px;\"/>');\n", - " titlebar.append(titletext)\n", - " this.root.append(titlebar);\n", - " this.header = titletext[0];\n", - "}\n", - "\n", - "\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._init_canvas = function() {\n", - " var fig = this;\n", - "\n", - " var canvas_div = $('<div/>');\n", - "\n", - " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", - "\n", - " function canvas_keyboard_event(event) {\n", - " return fig.key_event(event, event['data']);\n", - " }\n", - "\n", - " canvas_div.keydown('key_press', canvas_keyboard_event);\n", - " canvas_div.keyup('key_release', canvas_keyboard_event);\n", - " this.canvas_div = canvas_div\n", - " this._canvas_extra_style(canvas_div)\n", - " this.root.append(canvas_div);\n", - "\n", - " var canvas = $('<canvas/>');\n", - " canvas.addClass('mpl-canvas');\n", - " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", - "\n", - " this.canvas = canvas[0];\n", - " this.context = canvas[0].getContext(\"2d\");\n", - "\n", - " var backingStore = this.context.backingStorePixelRatio ||\n", - "\tthis.context.webkitBackingStorePixelRatio ||\n", - "\tthis.context.mozBackingStorePixelRatio ||\n", - "\tthis.context.msBackingStorePixelRatio ||\n", - "\tthis.context.oBackingStorePixelRatio ||\n", - "\tthis.context.backingStorePixelRatio || 1;\n", - "\n", - " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband = $('<canvas/>');\n", - " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", - "\n", - " var pass_mouse_events = true;\n", - "\n", - " canvas_div.resizable({\n", - " start: function(event, ui) {\n", - " pass_mouse_events = false;\n", - " },\n", - " resize: function(event, ui) {\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " stop: function(event, ui) {\n", - " pass_mouse_events = true;\n", - " fig.request_resize(ui.size.width, ui.size.height);\n", - " },\n", - " });\n", - "\n", - " function mouse_event_fn(event) {\n", - " if (pass_mouse_events)\n", - " return fig.mouse_event(event, event['data']);\n", - " }\n", - "\n", - " rubberband.mousedown('button_press', mouse_event_fn);\n", - " rubberband.mouseup('button_release', mouse_event_fn);\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband.mousemove('motion_notify', mouse_event_fn);\n", - "\n", - " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", - " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", - "\n", - " canvas_div.on(\"wheel\", function (event) {\n", - " event = event.originalEvent;\n", - " event['data'] = 'scroll'\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " mouse_event_fn(event);\n", - " });\n", - "\n", - " canvas_div.append(canvas);\n", - " canvas_div.append(rubberband);\n", - "\n", - " this.rubberband = rubberband;\n", - " this.rubberband_canvas = rubberband[0];\n", - " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", - " this.rubberband_context.strokeStyle = \"#000000\";\n", - "\n", - " this._resize_canvas = function(width, height) {\n", - " // Keep the size of the canvas, canvas container, and rubber band\n", - " // canvas in synch.\n", - " canvas_div.css('width', width)\n", - " canvas_div.css('height', height)\n", - "\n", - " canvas.attr('width', width * mpl.ratio);\n", - " canvas.attr('height', height * mpl.ratio);\n", - " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", - "\n", - " rubberband.attr('width', width);\n", - " rubberband.attr('height', height);\n", - " }\n", - "\n", - " // Set the figure to an initial 600x600px, this will subsequently be updated\n", - " // upon first draw.\n", - " this._resize_canvas(600, 600);\n", - "\n", - " // Disable right mouse context menu.\n", - " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", - " return false;\n", - " });\n", - "\n", - " function set_focus () {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " // put a spacer in here.\n", - " continue;\n", - " }\n", - " var button = $('<button/>');\n", - " button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n", - " 'ui-button-icon-only');\n", - " button.attr('role', 'button');\n", - " button.attr('aria-disabled', 'false');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - "\n", - " var icon_img = $('<span/>');\n", - " icon_img.addClass('ui-button-icon-primary ui-icon');\n", - " icon_img.addClass(image);\n", - " icon_img.addClass('ui-corner-all');\n", - "\n", - " var tooltip_span = $('<span/>');\n", - " tooltip_span.addClass('ui-button-text');\n", - " tooltip_span.html(tooltip);\n", - "\n", - " button.append(icon_img);\n", - " button.append(tooltip_span);\n", - "\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " var fmt_picker_span = $('<span/>');\n", - "\n", - " var fmt_picker = $('<select/>');\n", - " fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n", - " fmt_picker_span.append(fmt_picker);\n", - " nav_element.append(fmt_picker_span);\n", - " this.format_dropdown = fmt_picker[0];\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = $(\n", - " '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n", - " fmt_picker.append(option)\n", - " }\n", - "\n", - " // Add hover states to the ui-buttons\n", - " $( \".ui-button\" ).hover(\n", - " function() { $(this).addClass(\"ui-state-hover\");},\n", - " function() { $(this).removeClass(\"ui-state-hover\");}\n", - " );\n", - "\n", - " var status_bar = $('<span class=\"mpl-message\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "}\n", - "\n", - "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n", - "}\n", - "\n", - "mpl.figure.prototype.send_message = function(type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "}\n", - "\n", - "mpl.figure.prototype.send_draw_message = function() {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n", - " }\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "}\n", - "\n", - "\n", - "mpl.figure.prototype.handle_resize = function(fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1]);\n", - " fig.send_message(\"refresh\", {});\n", - " };\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n", - " var x0 = msg['x0'] / mpl.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n", - " var x1 = msg['x1'] / mpl.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0, 0, fig.canvas.width, fig.canvas.height);\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch(cursor)\n", - " {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_message = function(fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_draw = function(fig, msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message(\"ack\", {});\n", - "}\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function(fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = \"image/png\";\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src);\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data);\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - " else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig[\"handle_\" + msg_type];\n", - " } catch (e) {\n", - " console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n", - " }\n", - " }\n", - " };\n", - "}\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function(e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e)\n", - " e = window.event;\n", - " if (e.target)\n", - " targ = e.target;\n", - " else if (e.srcElement)\n", - " targ = e.srcElement;\n", - " if (targ.nodeType == 3) // defeat Safari bug\n", - " targ = targ.parentNode;\n", - "\n", - " // jQuery normalizes the pageX and pageY\n", - " // pageX,Y are the mouse positions relative to the document\n", - " // offset() returns the position of the element relative to the document\n", - " var x = e.pageX - $(targ).offset().left;\n", - " var y = e.pageY - $(targ).offset().top;\n", - "\n", - " return {\"x\": x, \"y\": y};\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys (original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object')\n", - " obj[key] = original[key]\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function(event, name) {\n", - " var canvas_pos = mpl.findpos(event)\n", - "\n", - " if (name === 'button_press')\n", - " {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * mpl.ratio;\n", - " var y = canvas_pos.y * mpl.ratio;\n", - "\n", - " this.send_message(name, {x: x, y: y, button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event)});\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "}\n", - "\n", - "mpl.figure.prototype.key_event = function(event, name) {\n", - "\n", - " // Prevent repeat events\n", - " if (name == 'key_press')\n", - " {\n", - " if (event.which === this._key)\n", - " return;\n", - " else\n", - " this._key = event.which;\n", - " }\n", - " if (name == 'key_release')\n", - " this._key = null;\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which != 17)\n", - " value += \"ctrl+\";\n", - " if (event.altKey && event.which != 18)\n", - " value += \"alt+\";\n", - " if (event.shiftKey && event.which != 16)\n", - " value += \"shift+\";\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, {key: value,\n", - " guiEvent: simpleKeys(event)});\n", - " return false;\n", - "}\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n", - " if (name == 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message(\"toolbar_button\", {name: name});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function() {\n", - " comm.close()\n", - " };\n", - " ws.send = function(m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function(msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data'])\n", - " });\n", - " return ws;\n", - "}\n", - "\n", - "mpl.mpl_figure_comm = function(comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = $(\"#\" + id);\n", - " var ws_proxy = comm_websocket_adapter(comm)\n", - "\n", - " function ondownload(figure, format) {\n", - " window.open(figure.imageObj.src);\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy,\n", - " ondownload,\n", - " element.get(0));\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element.get(0);\n", - " fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n", - " if (!fig.cell_info) {\n", - " console.error(\"Failed to find cell for figure\", id, fig);\n", - " return;\n", - " }\n", - "\n", - " var output_index = fig.cell_info[2]\n", - " var cell = fig.cell_info[0];\n", - "\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function(fig, msg) {\n", - " var width = fig.canvas.width/mpl.ratio\n", - " fig.root.unbind('remove')\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable()\n", - " $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n", - " fig.close_ws(fig, msg);\n", - "}\n", - "\n", - "mpl.figure.prototype.close_ws = function(fig, msg){\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "}\n", - "\n", - "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width/mpl.ratio\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n", - "}\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function() {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message(\"ack\", {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () { fig.push_to_output() }, 1000);\n", - "}\n", - "\n", - "mpl.figure.prototype._init_toolbar = function() {\n", - " var fig = this;\n", - "\n", - " var nav_element = $('<div/>')\n", - " nav_element.attr('style', 'width: 100%');\n", - " this.root.append(nav_element);\n", - "\n", - " // Define a callback function for later on.\n", - " function toolbar_event(event) {\n", - " return fig.toolbar_button_onclick(event['data']);\n", - " }\n", - " function toolbar_mouse_event(event) {\n", - " return fig.toolbar_button_onmouseover(event['data']);\n", - " }\n", - "\n", - " for(var toolbar_ind in mpl.toolbar_items){\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) { continue; };\n", - "\n", - " var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n", - " button.click(method_name, toolbar_event);\n", - " button.mouseover(tooltip, toolbar_mouse_event);\n", - " nav_element.append(button);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n", - " nav_element.append(status_bar);\n", - " this.message = status_bar[0];\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n", - " var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n", - " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", - " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", - " buttongrp.append(button);\n", - " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", - " titlebar.prepend(buttongrp);\n", - "}\n", - "\n", - "mpl.figure.prototype._root_extra_style = function(el){\n", - " var fig = this\n", - " el.on(\"remove\", function(){\n", - "\tfig.close_ws(fig, {});\n", - " });\n", - "}\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function(el){\n", - " // this is important to make the div 'focusable\n", - " el.attr('tabindex', 0)\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " }\n", - " else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "\n", - "}\n", - "\n", - "mpl.figure.prototype._key_event_extra = function(event, name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager)\n", - " manager = IPython.keyboard_manager;\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which == 13) {\n", - " this.canvas_div.blur();\n", - " event.shiftKey = false;\n", - " // Send a \"J\" for go to next cell\n", - " event.which = 74;\n", - " event.keyCode = 74;\n", - " manager.command_mode();\n", - " manager.handle_keydown(event);\n", - " }\n", - "}\n", - "\n", - "mpl.figure.prototype.handle_save = function(fig, msg) {\n", - " fig.ondownload(fig, null);\n", - "}\n", - "\n", - "\n", - "mpl.find_output_cell = function(html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i=0; i<ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code'){\n", - " for (var j=0; j<cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] == html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "}\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel != null) {\n", - " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", - "}\n" - ], - "text/plain": [ - "<IPython.core.display.Javascript object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<img src=\"data:image/png;base64,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\" width=\"960\">" - ], - "text/plain": [ - "<IPython.core.display.HTML object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "detecting face...\n" + ] + } + ], + "source": [ + "print('detecting face...')\n", + "st = time.time()\n", + "bboxes = face_detector.detect(im_resized, largest=True)\n", + "bbox = bboxes[0].to_dim(im_resized.shape[:2][::-1])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(68.0, 201.0) (110.0, 225.0) (-61.021374, 41.419292)\n" + "(72, 73, 197, 225)\n" ] } ], "source": [ + "bbox = bbox.to_xyxy()\n", + "print(bbox)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "points = fa.get_landmarks_from_image(im_resized, [bbox] )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "lm = fa.get_landmarks(im_rgb)[-1]\n", + "generate_3d_face_plain(im_rgb, lm)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ "im = cv.imread(fp_im)\n", "im_rgb = cv.cvtColor(im, cv.COLOR_BGR2RGB)\n", "lm = fa.get_landmarks(im_rgb)[-1]\n", @@ -976,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 393, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1100,20 +371,11 @@ }, { "cell_type": "code", - "execution_count": 394, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "time: 0.0017\n", - "Saved file to /home/adam/Downloads/0012_01.gif\n" - ] - } - ], + "outputs": [], "source": [ "# filepaths\n", "dir_out = '/home/adam/Downloads/'\n", @@ -1131,14 +393,79 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "from PIL import Image\n", + "fp_in = '/home/adam/Downloads/3d.gif'\n", + "im = Image.open(fp_in)\n", + "im_frames = []\n", + "duration = im.info['duration']\n", + "print(duration)" + ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "im = Image.open(fp_in)\n", + "#im_frame = im.seek(1)\n", + "im.seek(im.tell() + 1)\n", + "mypalette = im.getpalette()\n", + "im.putpalette(mypalette)\n", + "\n", + "im_jpg = Image.new(\"RGB\", im.size)\n", + "im_jpg.paste(im)\n", + "\n", + "im_jpg.save('/home/adam/Downloads/test.jpg')\n", + "print(im_jpg)\n", + "#plt.imshow(im_jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "im_jpg.getchannel(2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plt.imshow(im_jpg)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import dlib" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dlib.DLIB_USE_CUDA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from app.settings import app_cfg as cfg" + ] }, { "cell_type": "code", |