# take a bounding predicted by dlib and convert it

# to the format (x, y, w, h) as we would normally do

# with OpenCV

x = rect.left()

y = rect.top()

w = rect.right() - x

h = rect.bottom() - y

# return a tuple of (x, y, w, h)

# initialize the list of (x, y)-coordinates

coords = np.zeros((68, 2), dtype=dtype)

# loop over the 68 facial landmarks and convert them

# to a 2-tuple of (x, y)-coordinates

for i in range(0, 68):

coords[i] = (shape.part(i).x, shape.part(i).y)

# return the list of (x, y)-coordinates

("mouth", (48, 68)),

("right_eyebrow", (17, 22)),

("left_eyebrow", (22, 27)),

("right_eye", (36, 42)),

("left_eye", (42, 48)),

("nose", (27, 35)),

("jaw", (0, 17))

# Create greyscale image from the video feed

image = imutils.resize(frame, width=500)

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

ih, iw, _ = image.shape

# detect faces in the grayscale image

rects = detector(gray, 1)

#roi_color = frame #frame[y:y+h, x:x+w]

print(len(rects), "RECTS")

# loop over the face detections

for (i, rect) in enumerate(rects):

# determine the facial landmarks for the face region, then

# convert the facial landmark (x, y)-coordinates to a NumPy

# array

shape = predictor(gray, rect)

shape = face_utils.shape_to_np(shape)

# convert dlib's rectangle to a OpenCV-style bounding box

# [i.e., (x, y, w, h)], then draw the face bounding box

(x, y, w, h) = face_utils.rect_to_bb(rect)

#roi_gray = gray[y:y+h, x:x+w]

#roi_color = frame[y:y+h, x:x+w]

cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

# show the face number

#cv2.putText(image, "Face #{}".format(i + 1), (x - 10, y - 10),

# cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

# loop over the (x, y)-coordinates for the facial landmarks

# and draw them on the image

for (x, y) in shape:

cv2.circle(image, (x, y), 1, (0, 0, 255), -1)

#name = 'nose'

#i,j = face_utils.FACIAL_LANDMARKS_IDXS[name]

#for (i, name) in enumerate(FACIAL_LANDMARKS_IDXS.keys()):

i = 0

name = 'mouth'

if 1:

# grab the (x, y)-coordinates associated with the

# face landmark

(j, k) = FACIAL_LANDMARKS_IDXS[name]

pts = shape[j:k]

# check if are supposed to draw the jawline

if name == "jaw":

# since the jawline is a non-enclosed facial region,

# just draw lines between the (x, y)-coordinates

for l in range(1, len(pts)):

ptA = tuple(pts[l - 1])

ptB = tuple(pts[l])

#cv2.line(overlay, ptA, ptB, colors[i], 2)

cv2.line(image, ptA, ptB, colors[i], 2)

# otherwise, compute the convex hull of the facial

# landmark coordinates points and display it

else:

hull = cv2.convexHull(pts)

#cv2.drawContours(overlay, [hull], -1, colors[i], -1)

#cv2.drawContours(image, [hull], -1, colors[i], -1)

if name == 'mouth':

nx = np.min(pts[:,0])

ny = np.min(pts[:,1])

nw = np.max(pts[:,0])-np.min(pts[:,0])+1

nh = np.max(pts[:,1])-np.min(pts[:,1])+1

#cv2.rectangle(image,(nx,ny),(nx+nw,ny+nh),(255,0,0),2)

cv2.rectangle(image,(nx,ny),(nx+nw,ny+nh),colors[i])

mustacheWidth = 15 * nw

mustacheHeight = mustacheWidth * origMustacheHeight / origMustacheWidth

# Center the mustache on the bottom of the nose

x1 = nx - int(mustacheWidth/4.)

x2 = nx + nw + int(mustacheWidth/4.)

y1 = ny + nh - int(mustacheHeight/4.)

y2 = ny + nh + int((mustacheHeight/2.))

rx2,ry2 = pts[np.argmax(pts[:,0]),:]

rx1,ry1 = pts[np.argmin(pts[:,0]),:]

opp = ry2-ry1

adj = rx2-rx1

angle = -np.rad2deg(np.arctan(opp/float(adj)))

# Check for clipping

if x1 < 0:

x1 = 0

if y1 < 0:

y1 = 0

if x2 > iw:

x2 = iw

if y2 > ih:

y2 = ih

# Re-calculate the width and height of the mustache image

mustacheWidth = x2 - x1

mustacheHeight = y2 - y1

# Re-size the original image and the masks to the mustache sizes

# calcualted above

mustache = cv2.resize(imgMustache, (mustacheWidth,mustacheHeight), interpolation = cv2.INTER_AREA)

mustache_rot = imrotate(mustache, angle)

orig_mask_rot = imrotate(orig_mask, angle)

orig_mask_inv_rot = cv2.bitwise_not(orig_mask_rot)

mask = cv2.resize(orig_mask_rot, (mustacheWidth,mustacheHeight), interpolation = cv2.INTER_AREA)

mask_inv = cv2.resize(orig_mask_inv_rot, (mustacheWidth,mustacheHeight), interpolation = cv2.INTER_AREA)

# take ROI for mustache from background equal to size of mustache image

roi = image[y1:y2, x1:x2]

### roi_bg contains the original image only where the mustache is not

## in the region that is the size of the mustache.

roi_bg = cv2.bitwise_and(roi,roi,mask = mask_inv)

## roi_fg contains the image of the mustache only where the mustache is

roi_fg = cv2.bitwise_and(mustache,mustache,mask = mask)

## join the roi_bg and roi_fg

dst = cv2.add(roi_bg,roi_fg)

## place the joined image, saved to dst back over the original image

image[y1:y2, x1:x2] = dst