create_gif.py

# USAGE
# python create_gif.py --config config.json --image images/vampire.jpg --output out.gif

# import the necessary packages
from imutils import face_utils
from imutils import paths
import numpy as np
import argparse
import imutils
import shutil
import json
import dlib
import cv2
import sys
import os




def overlay_image(bg, fg, fgMask, coords):
	
	(sH, sW) = fg.shape[:2]
	(x, y) = coords

	
	overlay = np.zeros(bg.shape, dtype="uint8")   #黑色背景
	overlay[y:y + sH, x:x + sW] = fg

	
	alpha = np.zeros(bg.shape[:2], dtype="uint8")
	alpha[y:y + sH, x:x + sW] = fgMask
	alpha = np.dstack([alpha] * 3)

	
	output = alpha_blend(overlay, bg, alpha)

	
	return output

def alpha_blend(fg, bg, alpha):
	
	fg = fg.astype("float")
	bg = bg.astype("float")
	alpha = alpha.astype("float") / 255

	
	fg = cv2.multiply(alpha, fg)
	bg = cv2.multiply(1 - alpha, bg)

	
	output = cv2.add(fg, bg)

	# return the output image
	return output.astype("uint8")


def get_features(img_rd,*args):

	# 输入:  img_rd:      图像文件
	# 输出:  pos_69to81:  feature 69 to feature 81, 13 feature points in all, 40 points
	detector1 = dlib.get_frontal_face_detector()
	predictor1=dlib.shape_predictor(r"D:\PythonProject\birthday_crown\Creating-GIFs-with-OpenCV-master\assets\shape_predictor_81_face_landmarks.dat")
	# read img file
	img = cv2.imread(img_rd)
	# 取灰度
	img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

	# 计算 81 点坐标
	pos_81 = []
	rects = detector1(img_gray, 0)
	landmarks = np.matrix([[p.x, p.y] for p in predictor1(img, rects[0]).parts()])

	for idx, point in enumerate(landmarks):
		# 81点的坐标
		pos = (point[0, 0], point[0, 1])
		pos_81.append(pos)

	# pos_69to81 = []
	# # 将点 69-81 写入 CSV
	# # 即 pos_81[68]-pos_81[80]
	# for i in range(68, 81):
	# 	pos_69to81.append(pos_81[i][0])
	# 	pos_69to81.append(pos_81[i][1])
	# return pos_69to81
	get_pos=[]
	get_pos.append((pos_81[args[0]][0],pos_81[args[0]][1]))
	get_pos.append((pos_81[args[1]][0],pos_81[args[1]][1]))
	return get_pos
	

def create_gif(inputPath, outputPath, delay, finalDelay, loop):
	# grab all image paths in the input directory
	imagePaths = sorted(list(paths.list_images(inputPath)))

	# remove the last image path in the list
	lastPath = imagePaths[-1]
	imagePaths = imagePaths[:-1]

	
	cmd = "convert -delay {} {} -delay {} {} -loop {} {}".format(
		delay, " ".join(imagePaths), finalDelay, lastPath, loop,
		outputPath)
	os.system(cmd)


ap = argparse.ArgumentParser()
ap.add_argument("-c", "--config", required=True,
	help="path to configuration file")
ap.add_argument("-i", "--image", required=True,
	help="path to input image")
ap.add_argument("-o", "--output", required=True,
	help="path to output GIF")
args = vars(ap.parse_args())


config = json.loads(open(args["config"]).read())
sg = cv2.imread(config["sunglasses"])
sgMask = cv2.imread(config["sunglasses_mask"])


shutil.rmtree(config["temp_dir"], ignore_errors=True)
os.makedirs(config["temp_dir"])


print("[INFO] loading models...")
detector = cv2.dnn.readNetFromCaffe(config["face_detector_prototxt"],
	config["face_detector_weights"])
predictor = dlib.shape_predictor(config["landmark_predictor"])


image = cv2.imread(args["image"])
(H, W) = image.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 1.0,
	(300, 300), (104.0, 177.0, 123.0))


print("[INFO] computing object detections...")
detector.setInput(blob)
detections = detector.forward()


i = np.argmax(detections[0, 0, :, 2])
confidence = detections[0, 0, i, 2]


if confidence < config["min_confidence"]:
	print("[INFO] no reliable faces found")
	sys.exit(0)
	

# compute the (x, y)-coordinates of the bounding box for the face
box = detections[0, 0, i, 3:7] * np.array([W, H, W, H])
(startX, startY, endX, endY) = box.astype("int")

rect = dlib.rectangle(int(startX), int(startY), int(endX), int(endY))
shape = predictor(image, rect)
shape = face_utils.shape_to_np(shape)

forehead=get_features(args["image"],76,73)
print("额头"+str(forehead))

# print("LANDMARKS_IDXS"+str(face_utils.FACIAL_LANDMARKS_IDXS))
# (lStart, lEnd) = face_utils.FACIAL_LANDMARKS_IDXS["left_eye"]
# (rStart, rEnd) = face_utils.FACIAL_LANDMARKS_IDXS["right_eye"]
# leftEyePts = shape[lStart:lEnd]
# rightEyePts = shape[rStart:rEnd]
#
# # compute the center of mass for each eye
# leftEyeCenter = leftEyePts.mean(axis=0).astype("int")
# rightEyeCenter = rightEyePts.mean(axis=0).astype("int")

# compute the angle between the eye centroids
# dY = rightEyeCenter[1] - leftEyeCenter[1]
# dX = rightEyeCenter[0] - leftEyeCenter[0]
# angle = np.degrees(np.arctan2(dY, dX)) - 180
left_point=forehead[0]
right_point=forehead[1]

# left_point=shape[75].astype(int)
# right_point=shape[79].astype(int)

dY=left_point[1]-right_point[1]
dX=left_point[0]-right_point[0]
print("left_point:"+str(left_point[1]))
angle = np.degrees(np.arctan2(dY, dX)) - 180

# rotate the sunglasses image by our computed angle, ensuring the
# sunglasses will align with how the head is tilted
sg = imutils.rotate_bound(sg, angle)


# sgW = int((shape[16].astype(int)[0] - shape[0].astype(int)[0])*1.40)
sgW=int((endX-startX)*1.2)
sg = imutils.resize(sg, width=sgW)
print("sgw"+str(shape[16]))


sgMask = cv2.cvtColor(sgMask, cv2.COLOR_BGR2GRAY)
sgMask = cv2.threshold(sgMask, 0, 255, cv2.THRESH_BINARY)[1]
sgMask = imutils.rotate_bound(sgMask, angle)
sgMask = imutils.resize(sgMask, width=sgW, inter=cv2.INTER_NEAREST)



steps = np.linspace(0, left_point[1], config["steps"],
	dtype="int")

# start looping over the steps
for (i, y) in enumerate(steps):
	
	shiftX = int(sg.shape[1] * 0.18)
	shiftY = int(sg.shape[0]*0.80)
	y = max(0, y-shiftY)

	# add the sunglasses to the image
	output = overlay_image(image, sg, sgMask,
		(left_point[0]-shiftX, y))


	if i == len(steps) - 1:
		
		dwi = cv2.imread(config["deal_with_it"])
		dwiMask = cv2.imread(config["deal_with_it_mask"])
		dwiMask = cv2.cvtColor(dwiMask, cv2.COLOR_BGR2GRAY)
		dwiMask = cv2.threshold(dwiMask, 0, 255,
			cv2.THRESH_BINARY)[1]

		# resize both the text image and mask to be 80% the width of
		# the output image
		oW = int(W * 0.8)
		dwi = imutils.resize(dwi, width=oW)
		dwiMask = imutils.resize(dwiMask, width=oW,
			inter=cv2.INTER_NEAREST)

		# compute the coordinates of where the text will go on the
		# output image and then add the text to the image
		oX = int(W * 0.1)
		oY = int(H * 0.7)
		output = overlay_image(output, dwi, dwiMask, (oX, oY))

	# write the output image to our temporary directory
	p = os.path.sep.join([config["temp_dir"], "{}.jpg".format(
		str(i).zfill(8))])
	cv2.imwrite(p, output)


print("[INFO] creating GIF...")
create_gif(config["temp_dir"], args["output"], config["delay"],
	config["final_delay"], config["loop"])

# cleanup by deleting our temporary directory
print("[INFO] cleaning up...")
shutil.rmtree(config["temp_dir"], ignore_errors=True)