alignfaces 1.0.1__py3-none-any.whl

alignfaces/__init__.py

@@ -0,0 +1,15 @@
+"""
+*******************************************************
+*
+*  AlignFaces - INIT FILE
+*
+*  Version:      Version 1.0
+*  License:      Apache 2.0
+*  Written by:   Carl Michael Gaspar
+*  Created on:   March 14, 2019
+*  Last updated: March 14, 2019
+*
+*******************************************************
+"""
+
+from .make_aligned_faces import *

alignfaces/aperture_tools.py

@@ -0,0 +1,213 @@
+import numpy as np
+# Might need to import below into make_aligned_faces:
+#   from cv2 import imread, cvtColor, COLOR_BGR2GRAY, imwrite
+from skimage.filters import gaussian
+
+
+# Function to fit an ellipse using a very simple method.
+#   Semi-major axis (vertical) length is fixed as argument.
+#   Increase length of semi-minor until widest distance among landmarks fits.
+#   Immediate code above is redundant with this function.
+def fit_ellipse_semi_minor(semi_major, landmarks, center):
+    X, Y = landmarks[0], landmarks[1]
+    CX, CY = center[0], center[1]
+    Xc = X - CX
+    Yc = Y - CY
+    a_min = np.floor((Xc.max() - Xc.min()) * 3 / 10)
+    a = a_min
+    all_in = (((Xc**2/a**2) + (Yc**2/semi_major**2)) <= 1).all()
+    while (not all_in):
+        a += 1
+        all_in = (((Xc**2/a**2) + (Yc**2/semi_major**2)) <= 1).all()
+    return a
+
+
+def make_ellipse_map(semi_minor, semi_major, center, size, soften=True):
+    CX, CY = center[0], center[1]
+    x = np.array([i-CX for i in range(size[1])])
+    y = np.array([i-CY for i in range(size[0])])
+    xv, yv = np.meshgrid(x, y)
+    R = (xv**2) / semi_minor**2 + (yv**2) / semi_major**2
+    if soften:
+        # Soften edges using Butterworth as a function of radius from (CX, CY)
+        filter_n = 10
+        aperture = 1 / np.sqrt(1 + R**(2*filter_n))
+    else:
+        aperture = R <= 1
+    return aperture
+
+
+# Function to make a binary map of a circle within image of size = size.
+def make_circle_map(cxy, radius, size):
+    size = (size[1], size[0])
+    xx = np.array([[x - cxy[0] for x in range(1, size[0]+1)]
+                   for y in range(size[1])])
+    yy = np.array([[y - cxy[1] for y in range(1, size[1]+1)]
+                   for x in range(size[0])]).T
+    rr = np.sqrt(xx**2 + yy**2)
+    return rr <= radius
+
+
+# Function to make binary map selecting for entire image area below below_y
+def make_map_below_y(below_y, size):
+    size = (size[1], size[0])
+    yy = np.array([[y for y in range(1, size[1]+1)] for x in range(size[0])]).T
+    return yy > below_y
+
+
+# Function to make a binary aperture in shape of Moss's Egg.
+#
+#   1. ABC isosceles with point B facing down
+#       a. define upc, midpoint between A and C
+#       b. upc fraction along vector from mean of inter-eye midpoints
+#           to center of all landmarks
+#           i. fraction default is 1/4 but set as argument
+#       c. radius_upper is fraction of ellipse_width
+#           i. defined in ellipse-fitting functions
+#           ii. fraction default is 47/100 but set as argument
+#       d. A is upc shifted left by radius_upper
+#       e. C is upc shifted right by radius_upper
+#       f. B[x] is upc[x] and B[y] is mean of all nose-tips
+#   2. Rest of procedure follows basic construction of Moss's egg
+def make_moss_egg(landmark_features, center, size,
+                  fraction_width=47/100, soften=True):
+    CX, CY = center[0], center[1]
+
+    # Set radius_upper using same method used when fitting an elliptical
+    # aperture.
+    shapes = np.array(landmark_features['AllSubjectsLandmarksDict'])
+    X = shapes[:, 0::2].reshape(-1,)
+    Y = shapes[:, 1::2].reshape(-1,)
+    # Longest vertical length of ellipse that fits within image.
+    if (size[0] / 2) < CY:
+        ellipse_height = (size[0] - CY) * 2
+    elif (size[0] / 2) > CY:
+        ellipse_height = CY * 2
+    else:
+        ellipse_height = size[0]
+    semi_major = ellipse_height / 2
+    semi_minor = fit_ellipse_semi_minor(semi_major=semi_major,
+                                        landmarks=(X, Y),
+                                        center=(CX, CY))
+    ellipse_width = semi_minor * 2
+    radius_upper = ellipse_width * fraction_width
+
+    # Upper circle, centered on upc (midpoint of AC in ABC).
+    #   Top half defines top of Moss Egg.
+    to_center = 1 / 4
+    eye_midpoints = landmark_features['eye_midpoints']
+    eye_midpoint = np.array(eye_midpoints).mean(axis=0)
+    upc = ((CX, CY) - eye_midpoint) * to_center + (eye_midpoint)
+    horizontal_alignment = upc[0]
+
+    # Now make two large circles whose intersection defines middle part.
+
+    # Large circle on left, centered on cac
+    radius_large = radius_upper * 2
+    cac = (horizontal_alignment - radius_upper, upc[1])
+
+    # Large circle on right, centered on cbc
+    cbc = (horizontal_alignment + radius_upper, upc[1])
+
+    # Now make small circle at bottom, centered on lm.
+    nosey = np.array(landmark_features['nose_tips']).mean(axis=0)[1]
+    lm = (horizontal_alignment, nosey)
+
+    # Isosceles triangle cac -- lm -- cbc (ABC) with apex at lm.
+    # Ensure that angle at lm is greater than 60 degrees.
+    v1 = np.asarray(cac) - np.asarray(lm)
+    v2 = np.asarray(cbc) - np.asarray(lm)
+    acos = np.sum(v1 * v2) / (np.sqrt(np.sum(v1**2)) * np.sqrt(np.sum(v2**2)))
+    DegABC = np.arccos(acos) * 180 / np.pi
+    assert DegABC > 60
+
+    # Line defined by A (center of large circle) to lm.
+    #   m * x + y_intercept
+    #   m * x + c
+    delta = np.array(lm) - cac
+    m = delta[1] / delta[0]
+    t_intercept = -cac[0] / delta[0]
+    y_intercept = t_intercept * delta[1] + cac[1]
+
+    # Intersection of Ca with above line.
+    #
+    # (x - cac[0])**2 + (m * x + y_intercept - cac[1])**2 = radius_large**2
+    # (x -      p)**2 + (m * x +           c -      q)**2 =            r**2
+    A = m**2 + 1
+    B = 2 * (m * y_intercept - m*cac[1] - cac[0])
+    C = (cac[1]**2 - radius_large**2 + cac[0]**2 -
+         2*y_intercept*cac[1] + y_intercept**2)
+
+    assert B**2 - 4*A*C > 0
+
+    # Radius defined by distance from lm to above intersection.
+    # x_m = (-B - np.sqrt(B**2 - 4*A*C)) / (2*A)
+    x_p = (-B + np.sqrt(B**2 - 4*A*C)) / (2*A)
+    Ex = x_p
+    Ey = m * Ex + y_intercept
+    lower_radius = np.sqrt((((Ex, Ey) - np.array(lm))**2).sum())
+
+    Ca = make_circle_map(cxy=cac, radius=radius_large, size=size)
+    Cb = make_circle_map(cxy=cbc, radius=radius_large, size=size)
+    Cu = make_circle_map(cxy=upc, radius=radius_upper, size=size)
+    Cc = make_circle_map(cxy=lm, radius=lower_radius, size=size)
+
+    # LM1 = make_map_below_y(below_y=horizontal_alignment, size=size)
+    LM1 = make_map_below_y(below_y=upc[1], size=size)
+    LM2 = make_map_below_y(below_y=Ey, size=size)
+
+    EggA = Cu
+    EggB = Ca & Cb & LM1 & (LM2 == False)
+    EggC = Cc & LM2
+    # plt.imshow(np.c_[EggA, EggB, EggC])
+
+    MossEgg = EggA | EggB | EggC
+
+    if soften:
+        ME = MossEgg.astype(float)
+        IP = landmark_features['IrisPoints']
+        IPD = [np.sqrt(sum((I[1] - I[0])**2)) for I in IP]
+        sigma = round(np.asarray(IPD).mean() * 0.05)
+        MossEgg = gaussian(ME, sigma=(sigma, sigma),
+                           truncate=3.5 * sigma)
+        # MossEgg = gaussian(ME, sigma=(sigma, sigma),
+        #                    truncate=3.5 * sigma, multichannel=False)
+
+    # package critical variables for visualizing moss's egg construction
+    egg_params = {}
+    egg_params['A'] = cac
+    egg_params['B'] = lm
+    egg_params['C'] = cbc
+    egg_params['upc'] = upc
+    egg_params['radius_large'] = radius_large
+    egg_params['radius_upper'] = radius_upper
+    egg_params['radius_lower'] = lower_radius
+
+    return MossEgg, egg_params
+
+
+# Pack all into a four-channel image of unsigned 8-bit integers.
+def make_four_channel_image(img, aperture):
+    # assert aperture.min() >= 0 and aperture.max() <= 1
+    if not (aperture.min() >= 0 and aperture.max() <= 1):
+        aperture = aperture - aperture.min()
+        aperture = aperture / aperture.max()
+    alpha = (aperture * 255).astype(np.uint8)
+    if img.ndim == 2:
+        assert type(img[0, 0]) is np.uint8
+        size = img.shape
+        BGRA = np.zeros((size[0], size[1], 4), np.uint8)
+        for i in range(3):
+            BGRA[:, :, i] = img
+        BGRA[:, :, 3] = alpha
+    elif img.ndim == 3:
+        assert type(img[0, 0, 0]) is np.uint8
+        size = img.shape
+        BGRA = np.zeros((size[0], size[1], 4), np.uint8)
+        for i in range(3):
+            BGRA[:, :, i] = img[:, :, i]
+        BGRA[:, :, 3] = alpha
+    else:
+        BGRA = []
+        print("Warning: Image is neither grayscale nor RGB.")
+    return BGRA

alignfaces/contrast_tools.py

@@ -0,0 +1,106 @@
+import numpy as np
+from skimage import exposure
+
+# Ensures that values are centered on 127.5 and either reach until 0 or 255.
+#   full_image, numpy image array (any range of values)
+#   inner_locs, optional numpy binary map of inner face
+#               if supplied, all values are normalized but only properties
+#               within map are centered on 127.5 and reach until 0 or 255.
+#               no clipping occurs within map, but can occur outside.
+#
+#   output image is numpy array, unsigned 8-bit integers.
+def max_stretch_around_127(full_image, inner_locs=None):
+    if inner_locs is None:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch_around_127 to subregion" +
+              "can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    om = inner_values.mean()  # original mean value within binary map
+    inner_values = inner_values - om
+    if abs(inner_values.max()) > abs(inner_values.min()):
+        S = 127.5 / abs(inner_values.max())
+    elif abs(inner_values.max()) < abs(inner_values.min()):
+        S = 127.5 / abs(inner_values.min())
+
+    full_image = (full_image - om) * S + 127.5
+    return full_image.astype(np.uint8)
+
+
+# Ensures that values are centered on original mean and either reach until 0 or 255.
+#   full_image, numpy image array either [0-1] or [0-255]
+#               if [0-1] then multiplied by 255 to get original mean
+#   inner_locs, optional numpy binary map of inner face
+#               if supplied, all values are normalized but only properties
+#               within map are centered on 127.5 and reach until 0 or 255.
+#               no clipping occurs within map, but can occur outside.
+#
+#   output image is numpy array, unsigned 8-bit integers.
+def max_stretch_around_original_mean(full_image, inner_locs=None):
+    if (full_image.min() >=0) and (full_image.max()<=1):
+        full_image = full_image * 255
+    if inner_locs is None:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch_around_original_mean" +
+              "to subregion can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    om = inner_values.mean()  # original mean value within binary map
+    inner_values = inner_values - om
+    if abs(inner_values.max()) > abs(inner_values.min()):
+        # S = 127.5 / abs(inner_values.max())
+        # [om to 255]
+        # so maximum should now be equal to 255-om
+        # so multiply all by S where:
+        #     MX * S = 255 - om
+        #     S = (255 - om) / MX
+        S = (255 - om) / inner_values.max()
+    elif abs(inner_values.max()) < abs(inner_values.min()):
+        # S = 127.5 / abs(inner_values.min())
+        # [0 to om]
+        # so minimum should now be equal to -om
+        # so multiply all by:
+        #     MN * S = -om
+        #     S = -om / MN
+        S = -om / inner_values.min()
+    full_image = (full_image - om) * S + om
+    return full_image.astype(np.uint8)
+
+
+def max_stretch(full_image, inner_locs=None):
+    if inner_locs is None:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch to subregion" +
+              "can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    omin = inner_values.min()  # original mean value within binary map
+    inner_values = inner_values - omin
+    omax = inner_values.max()
+
+    full_image = (full_image - omin) / omax
+    full_image = full_image * 255
+    return full_image.astype(np.uint8)
+
+
+def contrast_stretch(full_image, inner_locs=None, type="max"):
+    if full_image.ndim == 3:
+        assert (type=="max") or (type==None)
+        if type == "max":
+            out_image = exposure.rescale_intensity(full_image)
+        return out_image
+    if type == "max":
+        out_image = max_stretch(full_image, inner_locs)
+    elif type == "mean_127":
+        out_image = max_stretch_around_127(full_image, inner_locs)
+    elif type == "mean_keep":
+        out_image = max_stretch_around_original_mean(full_image, inner_locs)
+    elif type == None:
+        out_image = full_image
+    else:
+        out_image = full_image
+        print("Warning: Invalid argument (type) to constrast_stretch.")
+    return out_image

alignfaces/contrast_tools_.py

@@ -0,0 +1,106 @@
+import numpy as np
+from skimage import exposure
+
+# Ensures that values are centered on 127.5 and either reach until 0 or 255.
+#   full_image, numpy image array (any range of values)
+#   inner_locs, optional numpy binary map of inner face
+#               if supplied, all values are normalized but only properties
+#               within map are centered on 127.5 and reach until 0 or 255.
+#               no clipping occurs within map, but can occur outside.
+#
+#   output image is numpy array, unsigned 8-bit integers.
+def max_stretch_around_127(full_image, inner_locs=[]):
+    if inner_locs==[]:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch_around_127 to subregion" +
+              "can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    om = inner_values.mean()  # original mean value within binary map
+    inner_values = inner_values - om
+    if abs(inner_values.max()) > abs(inner_values.min()):
+        S = 127.5 / abs(inner_values.max())
+    elif abs(inner_values.max()) < abs(inner_values.min()):
+        S = 127.5 / abs(inner_values.min())
+
+    full_image = (full_image - om) * S + 127.5
+    return full_image.astype(np.uint8)
+
+
+# Ensures that values are centered on original mean and either reach until 0 or 255.
+#   full_image, numpy image array either [0-1] or [0-255]
+#               if [0-1] then multiplied by 255 to get original mean
+#   inner_locs, optional numpy binary map of inner face
+#               if supplied, all values are normalized but only properties
+#               within map are centered on 127.5 and reach until 0 or 255.
+#               no clipping occurs within map, but can occur outside.
+#
+#   output image is numpy array, unsigned 8-bit integers.
+def max_stretch_around_original_mean(full_image, inner_locs=[]):
+    if (full_image.min() >=0) and (full_image.max()<=1):
+        full_image = full_image * 255
+    if inner_locs==[]:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch_around_original_mean" +
+              "to subregion can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    om = inner_values.mean()  # original mean value within binary map
+    inner_values = inner_values - om
+    if abs(inner_values.max()) > abs(inner_values.min()):
+        # S = 127.5 / abs(inner_values.max())
+        # [om to 255]
+        # so maximum should now be equal to 255-om
+        # so multiply all by S where:
+        #     MX * S = 255 - om
+        #     S = (255 - om) / MX
+        S = (255 - om) / inner_values.max()
+    elif abs(inner_values.max()) < abs(inner_values.min()):
+        # S = 127.5 / abs(inner_values.min())
+        # [0 to om]
+        # so minimum should now be equal to -om
+        # so multiply all by:
+        #     MN * S = -om
+        #     S = -om / MN
+        S = -om / inner_values.min()
+    full_image = (full_image - om) * S + om
+    return full_image.astype(np.uint8)
+
+
+def max_stretch(full_image, inner_locs=[]):
+    if inner_locs==[]:
+        inner_locs = np.ones(full_image.shape) == 1
+    else:
+        print("\nWarning: application of max_stretch to subregion" +
+              "can result in clipping outside that subregion.")
+
+    inner_values = full_image[inner_locs]
+    omin = inner_values.min()  # original mean value within binary map
+    inner_values = inner_values - omin
+    omax = inner_values.max()
+
+    full_image = (full_image - omin) / omax
+    full_image = full_image * 255
+    return full_image.astype(np.uint8)
+
+
+def contrast_stretch(full_image, inner_locs=[], type="max"):
+    if full_image.ndim == 3:
+        assert (type=="max") or (type==None)
+        if type == "max":
+            out_image = exposure.rescale_intensity(full_image)
+        return out_image
+    if type == "max":
+        out_image = max_stretch(full_image, inner_locs)
+    elif type == "mean_127":
+        out_image = max_stretch_around_127(full_image, inner_locs)
+    elif type == "mean_keep":
+        out_image = max_stretch_around_original_mean(full_image, inner_locs)
+    elif type == None:
+        out_image = full_image
+    else:
+        out_image = full_image
+        print("Warning: Invalid argument (type) to constrast_stretch.")
+    return out_image

alignfaces/face_landmarks.py

@@ -0,0 +1,233 @@
+import numpy as np
+
+# Facial landmark detection
+import dlib
+
+# Iris localisation
+# from .phase_cong_3 import phase_congruency
+from skimage.morphology import dilation
+from skimage.morphology import disk
+from skimage import feature
+from skimage.transform import hough_circle, hough_circle_peaks
+from skimage.draw import circle_perimeter
+from skimage.morphology import convex_hull_image
+import skimage
+
+# Formatting landmark data
+import itertools
+
+# Active contour for pulling upper subset of jawline
+# landmarks closer to hairline.
+from skimage.segmentation import active_contour
+
+# Import data file
+# from pkg_resources import resource_filename
+from importlib.resources import files
+
+import os
+
+
+def facial_landmarks(InputImage):
+
+    assert InputImage.ndim == 2 or InputImage.ndim == 3, \
+           'InputImage should be 2 or 3 dimensions.'
+
+    detector = dlib.get_frontal_face_detector()
+
+    # detect faces in the grayscale image
+    rects = detector(InputImage, 0)
+    if len(rects)==0:
+        rects = detector(InputImage, 1)
+    if len(rects)==0:
+        return
+    # assert len(rects)==1, 'Exactly one face must be detected in the image.'
+    rect = rects[0]
+
+    # determine the facial landmarks for the face region, then
+    # convert the facial landmark (x, y)-coordinates to a NumPy
+    # array
+    # predictor = dlib.shape_predictor('/Users/carl/Python Explore/models/shape_predictor_68_face_landmarks.dat')
+    # predictor = dlib.shape_predictor(resource_filename('alignfaces', 'data' + os.path.sep + 'shape_predictor_68_face_landmarks.dat'))
+    resource_file = files('alignfaces.data').joinpath('shape_predictor_68_face_landmarks.dat')
+    predictor = dlib.shape_predictor(str(resource_file))
+    shape = predictor(InputImage, rect)  # type: dlib.full_object_detection
+    shape = np.array([[tp.x, tp.y] for tp in shape.parts()])  # np (68 x XY)
+
+    assert len(shape)==68, 'Number of points returned by predictor must be 68.'
+
+    JAWLINE_POINTS = list(range(0, 17))
+    RIGHT_EYEBROW_POINTS = list(range(17, 22))
+    LEFT_EYEBROW_POINTS = list(range(22, 27))
+    NOSE_POINTS = list(range(27, 36))
+    RIGHT_EYE_POINTS = list(range(36, 42))
+    LEFT_EYE_POINTS = list(range(42, 48))
+    MOUTH_OUTLINE_POINTS = list(range(48, 61))
+    MOUTH_INNER_POINTS = list(range(61, 68))
+    Landmarks = {'JAWLINE_POINTS':shape[JAWLINE_POINTS,:], 'RIGHT_EYEBROW_POINTS':shape[RIGHT_EYEBROW_POINTS,:], \
+    'LEFT_EYEBROW_POINTS':shape[LEFT_EYEBROW_POINTS,:], 'NOSE_POINTS':shape[NOSE_POINTS,:], \
+    'RIGHT_EYE_POINTS':shape[RIGHT_EYE_POINTS,:], 'LEFT_EYE_POINTS':shape[LEFT_EYE_POINTS,:], \
+    'MOUTH_OUTLINE_POINTS':shape[MOUTH_OUTLINE_POINTS,:], 'MOUTH_INNER_POINTS':shape[MOUTH_INNER_POINTS,:]}
+    return Landmarks
+
+
+
+# def Iris(InputImage,Landmarks):
+#     assert InputImage.ndim==2, 'InputImage should be 2 dimensions.'
+#     nrows, ncols = InputImage.shape
+#     selem = disk(6) # use for dilation of binary maps
+#     M, m, EO = phase_congruency(InputImage, 4, 6)
+#     edges2 = feature.canny(M)
+#
+#     # Relevant labels for Landmarks
+#     labels = dict()
+#     labels[0] = 'LEFT_EYE_POINTS'
+#     labels[1] = 'RIGHT_EYE_POINTS'
+#     IrisPoints = dict()
+#
+#     hough_radii = np.arange(6, 9, 1) # range of radii to search
+#
+#     for fi in range(2):
+#         x = Landmarks[labels[fi]][:,0]
+#         y = Landmarks[labels[fi]][:,1]
+#         tempbw = np.zeros((nrows,ncols))
+#         tempbw[y, x] = 1
+#         ch = convex_hull_image(tempbw)
+#         dilated = dilation(ch, selem)
+#
+#         hough_res = hough_circle(dilated * edges2, hough_radii)
+#         accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii,total_num_peaks=8)
+#
+#         # Choose minimum of average pixel value within intersection of iris-disc and eye
+#         total_gray = [0] * max(accums.shape)
+#         i = -1
+#         for center_y, center_x, radius in zip(cy, cx, radii):
+#             i = i + 1
+#             circy, circx = circle_perimeter(center_y, center_x, radius)
+#             tempbw = np.zeros((nrows,ncols))
+#             tempbw[circy, circx] = 1
+#             ThisBw = convex_hull_image(tempbw)
+#             total_gray[i] = np.sum(ThisBw * ch * InputImage) / np.sum(ThisBw * ch)
+#
+#         best_of_hough = total_gray.index(min(total_gray))
+#         IrisPoints[fi] = (cy[best_of_hough], cx[best_of_hough], radii[best_of_hough])
+#
+#     return IrisPoints
+
+def unpack_dict_to_vector_xy(Landmarks):
+    LabelToCoordinateIndex = dict()
+    CoordinateVector = []
+    LabelToCoordinateIndex = dict()
+    starti = 0
+    for key in Landmarks.keys():
+        if isinstance(Landmarks[key], np.ndarray):
+            vform = Landmarks[key].flatten()
+        else:
+            vform = Landmarks[key]
+        CoordinateVector.append(vform)
+        endi = starti + len(vform)
+        LabelToCoordinateIndex[key] = list(range(starti, endi))
+        starti = endi
+    CoordinateVector = list(itertools.chain.from_iterable(CoordinateVector))
+    return CoordinateVector, LabelToCoordinateIndex
+
+def pack_vector_xy_as_dict(CoordinateVector, LabelToCoordinateIndex):
+    Landmarks = dict()
+    for key in LabelToCoordinateIndex.keys():
+        starti = LabelToCoordinateIndex[key][0]
+        endi = LabelToCoordinateIndex[key][-1]
+        clist = CoordinateVector[ starti : endi + 1 ]
+        ArrayForThisKey = (np.asarray(clist)).reshape((int((endi-starti+1)/2), 2))
+        Landmarks[key] = ArrayForThisKey
+    return Landmarks
+
+def pull_jawline_to_inside_of_hairline(Landmarks, Face):
+
+    # left side
+    cstart = Landmarks['JAWLINE_POINTS'][0,0] + Landmarks['JAWLINE_POINTS'][0,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][1,0] + Landmarks['JAWLINE_POINTS'][1,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkA = np.array([np.real(xy), np.imag(xy)]).T
+
+    cstart = Landmarks['JAWLINE_POINTS'][1,0] + Landmarks['JAWLINE_POINTS'][1,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][2,0] + Landmarks['JAWLINE_POINTS'][2,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkB = np.array([np.real(xy), np.imag(xy)]).T
+
+    cstart = Landmarks['JAWLINE_POINTS'][2,0] + Landmarks['JAWLINE_POINTS'][2,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][3,0] + Landmarks['JAWLINE_POINTS'][3,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkC = np.array([np.real(xy), np.imag(xy)]).T
+
+    upsampled_points = np.append(chunkA, chunkB[1:,:], axis=0)
+    upsampled_points = np.append(upsampled_points, chunkC[1:,:], axis=0)
+
+    init = upsampled_points
+
+    if (int((skimage.__version__).split(".")[1]) > 19):
+        # switch columns of init
+        init = np.roll(init, 1, axis=1)
+        snake = active_contour(Face, init, boundary_condition='free-fixed',
+                               alpha=0.1, beta=1.0, w_line=0, w_edge=5,
+                               gamma=0.1, convergence=0.01)
+        # switch columns of snake
+        snake = np.roll(snake, 1, axis=1)
+    elif (int((skimage.__version__).split(".")[1]) > 15):
+        # switch columns of init
+        init = np.roll(init, 1, axis=1)
+        snake = active_contour(Face, init, boundary_condition='free-fixed',
+                               alpha=0.1, beta=1.0, w_line=0, w_edge=5,
+                               gamma=0.1, convergence=0.01, coordinates='rc')
+        # switch columns of snake
+        snake = np.roll(snake, 1, axis=1)
+    else:
+        snake = active_contour(Face, init, bc='free-fixed',
+                               alpha=0.1, beta=1.0, w_line=0, w_edge=5,
+                               gamma=0.1, convergence=0.01)
+
+    Landmarks['JAWLINE_POINTS'][0:3,:] = snake[0:12:4,:]
+
+    # right side
+    cstart = Landmarks['JAWLINE_POINTS'][-1,0] + Landmarks['JAWLINE_POINTS'][-1,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][-2,0] + Landmarks['JAWLINE_POINTS'][-2,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkA = np.array([np.real(xy), np.imag(xy)]).T
+
+    cstart = Landmarks['JAWLINE_POINTS'][-2,0] + Landmarks['JAWLINE_POINTS'][-2,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][-3,0] + Landmarks['JAWLINE_POINTS'][-3,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkB = np.array([np.real(xy), np.imag(xy)]).T
+
+    cstart = Landmarks['JAWLINE_POINTS'][-3,0] + Landmarks['JAWLINE_POINTS'][-3,1]*1j
+    cend   = Landmarks['JAWLINE_POINTS'][-4,0] + Landmarks['JAWLINE_POINTS'][-4,1]*1j
+    xy = np.linspace(cstart, cend, 5)
+    chunkC = np.array([np.real(xy), np.imag(xy)]).T
+
+    upsampled_points = np.append(chunkA, chunkB[1:, :], axis=0)
+    upsampled_points = np.append(upsampled_points, chunkC[1:, :], axis=0)
+
+    init = upsampled_points
+
+    if (int((skimage.__version__).split(".")[1]) > 19):
+        # switch columns of init
+        init = np.roll(init, 1, axis=1)
+        snake = active_contour(Face, init, boundary_condition='free-fixed',
+                               alpha=0.1, beta=1.0, w_line=0, w_edge=5,
+                               gamma=0.1, convergence=0.01)
+        # switch columns of snake
+        snake = np.roll(snake, 1, axis=1)
+    elif (int((skimage.__version__).split(".")[1]) > 15):
+        # switch columns of init
+        init = np.roll(init, 1, axis=1)
+        snake = active_contour(Face, init, boundary_condition='free-fixed',
+                               alpha=0.1, beta=1.0, w_line=0, w_edge=5,
+                               gamma=0.1, convergence=0.01, coordinates='rc')
+        # switch columns of snake
+        snake = np.roll(snake, 1, axis=1)
+    else:
+        snake = active_contour(Face, init, bc='free-fixed', alpha=0.1,
+                               beta=1.0, w_line=0, w_edge=5, gamma=0.1,
+                               convergence=0.01)
+
+    Landmarks['JAWLINE_POINTS'][-1:-4:-1, :] = snake[0:12:4, :]
+    return Landmarks
+###############################################################################