add demos, in progress

8 files changed, 1088 insertions, 4 deletions

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