def __find_eyes(img):
coords = []
face_cascade = CascadeClassifier(
bin_path + '/Resources/Classifiers/haarcascade_frontalface.xml')
eye_cascade = CascadeClassifier(
bin_path + '/Resources/Classifiers/haarcascade_eye.xml')
gray = array(img.convert("L"))
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x, y, w, h) in faces:
roi_gray = gray[y:y + h, x:x + w]
eyes = eye_cascade.detectMultiScale(roi_gray)
for (ex, ey, ew, eh) in eyes:
coords.append((x + ex + ew / 2, y + ey + eh / 2))
return coords
def __call__(self, _tuple):
""" The processing
Args:
_tuple: process the image_string f9eld
Returns:
faces_regions added to tuple None on failure
"""
if self.haar_file is None:
self.haar_file = streamsx.ec.get_application_directory(
) + "/etc/haarcascade_frontalface_default.xml"
if self.haar_cascade_face is None:
self.haar_cascade_face = CascadeClassifier(self.haar_file)
bio = io.BytesIO(base64.b64decode(_tuple['image_string']))
img_raw = self.bts_to_img(bio.read())
if img_raw is None:
img_url = _tuple['img_desc'][0]['img']
logging.getLogger(__name__).warning(
"Fail bts_to_img() on url: {}".format(img_url))
return None
print("Size of image to process : ", img_raw.shape)
img_rgb = self.convertToRGB(img_raw)
face_rects = self.haar_cascade_face.detectMultiScale(img_rgb,
scaleFactor=1.2,
minNeighbors=5)
if len(face_rects) is 0:
return None
_tuple['face_regions'] = face_rects.tolist()
return _tuple
def __enter__(self):
if self.haar_file is None:
self.haar_file = streamsx.ec.get_application_directory(
) + "/etc/haarcascade_frontalface_default.xml"
if self.haar_cascade_face is None:
self.haar_cascade_face = CascadeClassifier(self.haar_file)
return self
def detect_face_cv2_webcam():
cap = VideoCapture(0)
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
# Check if the webcam is opened correctly
if not cap.isOpened():
raise IOError("Cannot open webcam")
while True:
ret, frame = cap.read()
frame = flip(frame, 1)
gray = cvtColor(frame, COLOR_BGR2GRAY)
faces = classifier.detectMultiScale(
gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
# flags=cv2.cv.CV_HAAR_SCALE_IMAGE
)
for (x, y, w, h) in faces:
rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
imshow("Video", frame)
if waitKey(1) == ord('q'):
break
cap.release()
destroyAllWindows()
def start(self, vid_path):
self.tracker = BarbellTracker('')
self.s3_dao.download_file_from_s3(config.S3_BUCKET, vid_path,
self.vid_location)
# Create the classifier to detect the barbell
classifier = CascadeClassifier(config.CLASSIFIER_LOCATION)
# Load the video into the tracker
self.tracker.load_video(self.vid_location)
# Get the FPS of the video
fps = self.tracker.get_video_fps()
# Apply the classifier to the video
frame, pos, cm_multiplier = self.tracker.detect_barbell_pos(classifier)
# Track the detected objcet throughout the video
dist_list = self.tracker.track(frame, pos)
# Add results to the DB
Session = sessionmaker(bind=self.db_eng)
db_session = Session()
video = db_session.query(Video).filter_by(s3_path=vid_path).first()
# Update the video to add attributes determined by the tracker
video.fps = fps
video.cm_multiplier = cm_multiplier
dist_ctr = 1
for distance in dist_list:
bar_distance = BarDistance(video.vid, dist_ctr, distance)
db_session.add(bar_distance)
dist_ctr += 1
db_session.commit()
def main():
image_list = [
file for file in os.listdir('Dataset') if file.endswith('.jpg')
]
image_list.sort()
# load the pre-trained model
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
j = 0
for i in image_list[:10]:
j = j + 1
# load the photograph
pixels = imread('Dataset/' + i)
# perform face detection
bboxes, p, q = classifier.detectMultiScale3(pixels,
scaleFactor=1.05,
minNeighbors=8,
outputRejectLevels=True)
# print bounding box for each detected face
#print('Number of faces detected in '+i+' : '+str(len(bboxes)))
for box, conf in zip(bboxes, q):
if conf > 1:
# extract
x, y, width, height = box
x2, y2 = x + width, y + height
# draw a rectangle over the pixels
rectangle(pixels, (x, y), (x2, y2), (0, 0, 255), 2)
imwrite('Output/Face_Detection_Haar' + str(j) + str(i), pixels)
def cropFace(img):
# load the photograph
# pixels = img
pixels = img
# load the pre-trained model
classifier = CascadeClassifier(
'face_detect/haarcascade_frontalface_default.xml')
# perform face detection
bboxes = classifier.detectMultiScale(pixels)
if len(bboxes) == 0:
print("ERROR: No faces found.")
# extract
x, y, width, height = bboxes[0]
x2, y2 = x + width, y + height
BUFFER = int(width * 0.25)
# show the image
image = pixels[max(y - BUFFER, 0):min(y2 + BUFFER, pixels.shape[0]),
max(x - BUFFER, 0):min(x2 + BUFFER, pixels.shape[1])]
# imshow('hehe', image)
# waitKey(0)
return image
def main():
image_list = [
file for file in os.listdir('Dataset') if file.endswith('.jpg')
]
image_list.sort()
# load the pre-trained model
classifier = CascadeClassifier('lbpcascade_frontalface.xml')
j = 0
for i in image_list[:10]:
j = j + 1
# load the photograph
pixels = imread('Dataset/' + i)
# perform face detection
bboxes = classifier.detectMultiScale(pixels)
# print bounding box for each detected face
#print('Number of faces detected in '+i+' : '+str(len(bboxes)))
for box in bboxes:
# extract
x, y, width, height = box
x2, y2 = x + width, y + height
# draw a rectangle over the pixels
rectangle(pixels, (x, y), (x2, y2), (0, 0, 255), 2)
imwrite('Output/Face_Detection_LBP' + str(i), pixels)
def crop(self, input_image, output_filename=None, to_gray=False):
image = asarray(input_image)
img_height, img_width = image.shape[:2]
minface = int(sqrt(img_height ** 2 + img_width ** 2) / self.minface)
# create the haar cascade
face_cascade = CascadeClassifier(self.casc_path)
# detect faces in the image
faces = face_cascade.detectMultiScale(
cvtColor(image, COLOR_BGR2GRAY),
scaleFactor=1.1,
minNeighbors=5,
minSize=(minface, minface),
flags=CASCADE_FIND_BIGGEST_OBJECT | CASCADE_DO_ROUGH_SEARCH,
)
# handle no faces
if len(faces) == 0:
return None
# make padding from biggest face found
x, y, w, h = faces[-1]
pos = self._crop_positions(img_height, img_width, x, y, w, h,)
# actual cropping
image = image[pos[0]: pos[1], pos[2]: pos[3]]
# resize
image = resize(image, (self.width, self.height), interpolation=INTER_AREA)
if output_filename:
if to_gray:
Image.fromarray(image).convert("L").save(output_filename)
else:
cv2.imwrite(output_filename, image)
return image
def face_detection(self) -> bool:
"""Detects faces by converting it to grayscale and neighbor match method.
Returns:
bool:
A boolean value if not a face was detected.
"""
cascade = CascadeClassifier(data.haarcascades +
"haarcascade_frontalface_default.xml")
for _ in range(20):
ignore, image = self.validation_video.read(
) # reads video from web cam
scale = cvtColor(
image,
COLOR_BGR2GRAY) # convert the captured image to grayscale
scale_factor = 1.1 # specify how much the image size is reduced at each image scale
min_neighbors = 5 # specify how many neighbors each candidate rectangle should have to retain it
faces = cascade.detectMultiScale(
scale, scale_factor,
min_neighbors) # faces are listed as tuple here
# This is a hacky way to solve the problem. The problem when using "if faces:":
# ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
# When used either of the suggestion:
# AttributeError: 'tuple' object has no attribute 'any' / 'all'
# But happens only when the value is true so ¯\_(ツ)_/¯
try:
if faces:
pass
except ValueError:
imwrite('cv2_open.jpg', image)
self.validation_video.release()
return True
def __init__(
self,
cascadeXMLFilePath:
str = './resources/face_detectors/facedetect_haarcascade_frontalface_default.xml',
postProcessCallback=None):
super().__init__(postProcessCallback=postProcessCallback)
# check if file exists
open(cascadeXMLFilePath, 'r').close()
self.face_cascade = CascadeClassifier(cascadeXMLFilePath)
def main():
cascade = CascadeClassifier('cascades/haarcascade_frontalface_default.xml')
model = load_model('my_models/my_model_small.h5')
image_BGR, image_gray = load_image('test_images/test_image_1.jpg')
faces = detect_cascade(image_gray, cascade, scaleFactor=4)
facialFeatures = detect_facial_features(image_gray, faces, model)
image_BGR = add_sunglasses(image_BGR, faces, facialFeatures)
imwrite('output.jpg', image_BGR)
async def Start(self) -> None:
self.face_cascade = CascadeClassifier(f"Files/{Settings.cascade}")
if (not self.cap):
self.cap = VideoCapture(Settings.capIndex)
self.cap.set(3, Settings.resolution[0])
self.cap.set(4, Settings.resolution[1])
if (Settings.port):
if (self.serialArduino): self.serialArduino.close()
self.serialArduino = serial.Serial(port=Settings.port,
baudrate=Settings.speed)
def start(q, postURLe):
global embeddedDB
global postURL
postURL = postURLe
embedUpdateTimeout = 0
fetchEmbedded()
detector = CascadeClassifier("haarcascade_frontalface_default.xml")
prevName = None
while True:
time.sleep(0.1)
if (not (q.empty())):
if (embedUpdateTimeout == 6):
#fetchEmbedded()
embedUpdateTimeout = 0
frame = imutils.resize(q.get(), width=500)
frame = cvtColor(frame, COLOR_BGR2RGB)
frameGray = cvtColor(frame, COLOR_BGR2GRAY)
rects = detector.detectMultiScale(frame,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=CASCADE_SCALE_IMAGE)
boxes = [(y, x + w, y + h, x) for (x, y, w, h) in rects]
sendBoxes = [(x, y, x + w, y + h) for (x, y, w, h) in rects]
encodings = face_recognition.face_encodings(frame, boxes)
names = []
for encoding in encodings:
matches = face_recognition.compare_faces(
embeddedDB["encodings"], encoding, tolerance=0.48)
name = "Unknown"
if True in matches:
matchedIdxs = [i for (i, b) in enumerate(matches) if b]
counts = {}
for i in matchedIdxs:
name = embeddedDB["names"][i]
counts[name] = counts.get(name, 0) + 1
name = max(counts, key=counts.get)
names.append(name)
if (len(names) > 0):
if (prevName == names[0]):
eventLogger.eventLogger(frame, sendBoxes[0], names[0],
postURL)
if (names[0] != "Unknown"):
print("Recognized: " + names[0])
lockCtrl.unlock()
else:
print("Unrecognized stranger!")
prevName = names[0]
else:
eventLogger.eventLogger(frame, None, None, postURL)
embedUpdateTimeout += 1
def init_face_classifier():
"""
Load the Cascade Classifier and initialize it with the weights from the Haar Cascade Classifier.
"""
print('\n\nLoading the Cascade Classifier')
# try:
facec = CascadeClassifier('models/haarcascade_frontalface_default.xml')
print('Cascade Classifier Loaded Successfully')
# except:
# print('ERROR: Could not Load the Cascade Classifier')
# sys.exit(1)
return facec
def main():
classifier1 = CascadeClassifier('haarcascade_frontalface_default.xml')
classifier2 = CascadeClassifier('lbpcascade_frontalface.xml')
video_capture = cv2.VideoCapture(0)
while True:
# Capture frame-by-frame
start = time.time()
ret, frame = video_capture.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces1, p, confidence1 = classifier1.detectMultiScale3(
gray, scaleFactor=1.05, minNeighbors=8, outputRejectLevels=True)
# Draw a Green rectangle around the faces identified by HAAR_Cascade
for (x, y, w, h), conf1 in zip(faces1, confidence1):
if conf1 > 1:
rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
faces2, q, confidence2 = classifier2.detectMultiScale3(
gray, scaleFactor=1.05, minNeighbors=8, outputRejectLevels=True)
# Draw a Blue rectangle around the faces identified by LBP
for (x, y, w, h), conf2 in zip(faces2, confidence2):
if conf2 > 1:
rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
cv2.imshow('Video', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
end = time.time()
print('time taken to execute one frame ', end - start)
video_capture.release()
cv2.destroyAllWindows()
def __init__(self, file_path=None):
"""Init Haar Cascade Classifier
Create classifier instance with given XML file.
Download XML from the web if the file does not exist.
Args:
file_path: the path for cascade classifier XML file
"""
if not file_path:
file_path = FaceDetector.get_abs_path()
if not exists(file_path):
FaceDetector.download_haarcascade_xml(file_path)
self.ccc = CascadeClassifier(file_path)
def __init__(self, fl, lock, fps=None):
# Reference to lock > I'm not sure if I am doing this correctly
self.lock = lock
# Reference to the FrameLoop object (instance)
self.fl_ref = fl
# The target fps
self.target_fps = fps if fps else fl.fps
# The current frame of the FrameLoop
self.frame = None
# The current frame of the FrameLoop (.jpg encoded)
self.encodedFrame = None
# Classifier reference
self.face_cascade = CascadeClassifier(data.haarcascades + 'haarcascade_frontalface_default.xml')
def crop_face(img):
"""
Given an image with a single face, crop the face out and return it.
:param img:
:return:
"""
# get face classifier
face_cascade = CascadeClassifier(
"../data/haarcascades/haarcascade_frontalface_default.xml")
# detect all faces
detected = face_cascade.detectMultiScale(img, 1.2, 5)
# get first face detected (probably the largest one)
(x, y, w, h) = detected[0]
# return cropped image
return img[y:y + w, x:x + h]
def __init__(self,
path_to_face_points,
path_to_hc_model,
scale=1,
minNeighbors=5):
# load_weigths face detector model
self.detector = CascadeClassifier(
str(path_to_hc_model)).detectMultiScale
# parameters for face detector model
self.scale = scale
self.minNeighbors = minNeighbors
# load_weigths face landmarks detector model
self.predictor = shape_predictor(str(path_to_face_points))
def classify(model, cascade_classifier_path_xml, transformations=None):
cap = cv2.VideoCapture(0)
face_cascade = CascadeClassifier(cascade_classifier_path_xml)
while True:
ret, img_bgr = cap.read()
gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray, 1.3, 2)
for (x, y, w, h) in faces:
w += 20
h += 20
r = max(w, h) / 2
centerx = x + w / 2
centery = y + h / 2
nx = int(centerx - r)
ny = int(centery - r)
nr = int(r * 2)
faceimg_bgr = img_bgr[ny:ny + nr, nx:nx + nr]
predimg = transformations(faceimg_bgr)
predimg = np.expand_dims(predimg.numpy(), axis=0)
outputs = model(torch.Tensor(predimg))
_, prediction = torch.max(outputs.data, 1)
prediction = prediction.item()
if prediction == 1:
img_bgr = cv2.rectangle(img_bgr, (x, y), (x + w, y + h),
(0, 0, 255), 2)
cv2.putText(img_bgr, 'No Mask', (x, y - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
elif prediction == 0:
img_bgr = cv2.rectangle(img_bgr, (x, y), (x + w, y + h),
(0, 255, 0), 2)
cv2.putText(img_bgr, 'Mask', (x, y - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
cv2.namedWindow("img_1")
cv2.imshow('img_1', img_bgr)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
def detect_face_cv2(img):
# load the photograph
pixels = imread(img)
# load the pre-trained model
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
# perform face detection
bboxes = classifier.detectMultiScale(pixels,
scaleFactor=1.05,
minNeighbors=8
)
# print bounding box for each detected face
for box in bboxes:
x, y, width, height = box
x2, y2 = x + width, y + height
rectangle(pixels, (x, y), (x2, y2), (0, 0, 255), 1)
imshow("face detection", pixels)
waitKey(0)
destroyAllWindows()
def __init__(self, cascade_object=None, scale_factor=2.5, min_neighbors=5):
"""Create a Cascade Scanner
Parameters
----------
cascade_object : str | ClassifierObject
a model used for object detection
scale_factor : float
the scale with which the image will be resized
min_neighbors : int
a parameter needed for the object detection
"""
self.scale_factor = scale_factor
self.min_neighbors = min_neighbors
if cascade_object is not None:
if cascade_object is not str:
self.cascade_object = cascade_object
else:
self.cascade_object = CascadeClassifier(cascade_object)
def face_detection(path):
# Create the haar cascade
faceCascade = CascadeClassifier(cv2.data.haarcascades +
'haarcascade_frontalface_default.xml')
# Read the image
image = cv2.imread(path)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# Detect faces in the image
faces = faceCascade.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(30, 30),
flags=cv2.CASCADE_SCALE_IMAGE)
# Draw a rectangle around the faces
for (x, y, w, h) in faces:
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
return len(faces), image
def camera_prediction(model):
frequency = 0.02 # minutes
instant = -1
faceCascade = CascadeClassifier('haarcascade_frontalface_alt.xml')
capture = VideoCapture(0)
while True:
ret, frame = capture.read()
image = copy.deepcopy(frame)
gray = cvtColor(frame, COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale(gray,
scaleFactor=1.1,
minNeighbors=5,
minSize=(image_width,
image_height),
flags=CASCADE_SCALE_IMAGE)
captured_face = None
for (x, y, w, h) in faces:
rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
captured_face = gray[y:y + h, x:x + w]
imshow('Face detector', frame)
if captured_face is not None:
captured_face = resize(captured_face, (image_width, image_height))
instant = classify_emotion(model, captured_face, instant,
frequency)
captured_face = None
if waitKey(1) & 0xFF == ord('q'):
break
video_capture.release()
destroyAllWindows()
def opencv_detect(image):
"""
Detects a face using OpenCV's cascade detector
Returns a list of arrays containing (x, y, width, height) for each detected
face.
"""
from cv2 import CascadeClassifier
cc = CascadeClassifier(
'./bob/prepare_eyes_annotations/util/data/haarcascade_frontalface_alt.xml'
)
faces = cc.detectMultiScale(
image,
1.3, #scaleFactor (at each time the image is re-scaled)
4, #minNeighbors (around candidate to be retained)
0, #flags (normally, should be set to zero)
(20, 20), #(minSize, maxSize) (of detected objects on that scale)
)
if (len(faces) == 0):
faces = [[0, 0, image.shape[0], image.shape[1]]]
return faces
def cropFace(img_path):
img = cv2.imread(img_path)
# load the photograph
# pixels = img
pixels = img
# load the pre-trained model
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
# perform face detection
bboxes = classifier.detectMultiScale(pixels)
if len(bboxes) == 0:
print("ERROR: No faces found.")
return None
# extract
x, y, width, height = bboxes[0]
x2, y2 = x + width, y + height
BUFFER = int(width * 0.25)
images = []
# show the image
for i in range(len(bboxes)):
x, y, width, height = bboxes[i]
x2, y2 = x + width, y + height
images.append(
pixels[max(y - BUFFER, 0):min(y2 + BUFFER, pixels.shape[0]),
max(x - BUFFER, 0):min(x2 + BUFFER, pixels.shape[1])])
# imshow('hehe', images[i])
# waitKey(0)
images[i] = cv2.cvtColor(images[i], cv2.COLOR_BGR2RGB)
return images
def __init__(self):
# create classifier to determine what a face is
self.face_cascade = CascadeClassifier(
"../data/haarcascades/haarcascade_frontalface_default.xml")
self.trackers = [] # object tracker for each face
self.tracking_count = 0
import cv2
from cv2 import CascadeClassifier
from cv2 import imread
from cv2 import rectangle
from cv2 import imshow
from cv2 import waitKey
from cv2 import destroyAllWindows
#print(cv2.__version__)
#Cargamos un modelo pre-entrenado para reconocimiento facial y creamos un modelo en cascada con el
classifier = CascadeClassifier('haarcascade_frontalface_default.xml')
#cargamos una foto de prueba
pixels = imread('image/foto grupal.jpg')
#realizamos el reconocimiento facial. 1.1 significa ampliar la foto un 10% y 3 indica el nivel de fiabilidad de la deteccion
bboxes = classifier.detectMultiScale(pixels, 1.1, 3)
#representamos los cuadros delimitadores de los rostros detectados
for box in bboxes:
print(box)
# para mostrar la imagen original con los cuadros delimitadores dibujados encima haremos lo siguiente:
# extraemos cada propiedad del resultado (x e y de la esquina inferior izq del cuadro delimitador y su altura y anchura)
x, y, width, height = box
x2, y2 = x + width, y + height
# dibujamos un rectangulo sobre los pixels
rectangle(pixels, (x, y), (x2, y2), (0, 0, 255), 1)
#imprimimos la imagen con la deteccion y la mantenamos abierta hasta que el usuario pulse una tecla
#mostramos la imagen
imshow('face detection', pixels)
#mantenemos la ventana abierta hasta que se pulse una tecla
def detect_human_face():
# 得到user目录下的所有文件名称，即各个好友头像
pics = listdir('image')
# 使用人脸的头像个数
count_face_image = 0
# 存储使用人脸的头像的文件名
list_name_face_image = []
# 加载人脸识别模型
face_cascade = CascadeClassifier(
'model/haarcascade_frontalface_default.xml')
for index, file_name in enumerate(pics):
print(u'正在进行人脸识别，进度%d/%d，请耐心等待……' % (index + 1, len(pics)))
# 读取图片
img = imread('image/' + file_name)
# 检测图片是否读取成功，失败则跳过
if img is None:
continue
# 对图片进行灰度处理
gray = cvtColor(img, COLOR_BGR2GRAY)
# 进行实际的人脸检测，传递参数是scaleFactor和minNeighbor,分别表示人脸检测过程中每次迭代时图
faces = face_cascade.detectMultiScale(gray, 1.3, 5)
if (len(faces) > 0):
count_face_image += 1
list_name_face_image.append(file_name)
print(u'使用人脸的头像%d/%d' % (count_face_image, len(pics)))
# 开始拼接使用人脸的头像
pics = list_name_face_image
numPic = len(pics)
eachsize = int(math.sqrt(float(640 * 640) /
numPic)) # 先圈定每个正方形小头像的边长，如果嫌小可以加大
numrow = int(640 / eachsize)
numcol = int(numPic / numrow) # 向下取整
toImage = Image.new('RGB',
(eachsize * numrow, eachsize * numcol)) # 先生成头像集模板
x = 0 # 小头像拼接时的左上角横坐标
y = 0 # 小头像拼接时的左上角纵坐标
for index, i in enumerate(pics):
print(u'正在拼接使用人脸的微信好友头像数据，进度%d/%d，请耐心等待……' % (index + 1, len(pics)))
try:
# 打开图片
img = Image.open('image/' + i)
except IOError:
print(u'Error: 没有找到文件或读取文件失败')
else:
# 缩小图片
img = img.resize((eachsize, eachsize), Image.ANTIALIAS)
# 拼接图片
toImage.paste(img, (x * eachsize, y * eachsize))
x += 1
if x == numrow:
x = 0
y += 1
toImage.save('data/使用人脸的拼接' + ".jpg")
# 生成一个网页
with open('data/使用人脸的微信好友头像拼接图.html', 'w', encoding='utf-8') as f:
data = '''
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv='Content-Type' content='text/html; charset=utf-8'>
<meta charset="utf-8" />
<title>使用人脸的微信好友头像拼接图</title>
</head>
<body>
<p><font size=4px><strong>描述内容</strong></font></p>
<img src="使用人脸的拼接.jpg" />
</body>
</html>
'''
data = data.replace(
'描述内容', '在{}个好友中，有{}个好友使用真实的人脸作为头像'.format(len(friends),
count_face_image))
f.write(data)
