import cv2
def face_detect_demo():
    # 首先先将图片灰度化处理
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 加载特征数据
    face_detector = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    faces = face_detector.detectMultiScale(gray,scaleFactor=1.2)
    for x, y, w, h in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), color=(0, 255, 0), thickness=2)
    # 显示图片
    cv2.imshow('result', img)


# 加载图片
img = cv2.imread('2.jpg')
# 调用人脸检测函数
face_detect_demo()
cv2.waitKey()
cv2.destroyAllWindows()

import cv2
import os

# 加载人脸检测器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

# 打开视频文件或摄像头
cap = cv2.VideoCapture('1.mp4')  # 或者使用摄像头：cap = cv2.VideoCapture(0)

# 创建保存图像的文件夹
image_folder = 'face_images'
if not os.path.exists(image_folder):
    os.makedirs(image_folder)

# 人物标签和计数器
people_labels = []
counter = 0

while True:
    # 读取视频帧
    ret, frame = cap.read()
    if not ret:
        break

        # 转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, 1.1, 4)
    for (x, y, w, h) in faces:
        # 在人脸周围画一个矩形框
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

        # 检查是否是新人物
        if counter == 0:
            people_labels.append('person-1')
            # 保存第一张图片并重置计数器
            face_img = gray[y:y + h, x:x + w]  # 从原始图像中提取人脸部分
            cv2.imwrite(os.path.join(image_folder, people_labels[-1] + '.png'), face_img)  # 保存图像，并使用最新标签命名图片
            counter = -1  # 重置计数器，表示已经处理过一个人脸了，但是不再保存新图片
        else:  # 如果不是第一张人脸
            # 检查是否已经存在同名标签，如果是则移除它
            if people_labels[counter - 1] in ['person-1', 'person-2', 'person-3', 'person-4']:
                people_labels.append(people_labels[counter - 1] + '-2')  # 例如，person-2-2表示第二个出现的person-2人物，但不再保存图片
            else:  # 如果不是同名标签，则添加新的标签并保存图片
                people_labels.append('person-' + str(len(people_labels) + 1))  # 例如，person-5表示第五个人物，但不再保存图片
                face_img = gray[y:y + h, x:x + w]  # 从原始图像中提取人脸部分
                cv2.imwrite(os.path.join(image_folder, people_labels[-1] + '.png'), face_img)  # 保存图像，并使用最新标签命名图片
        counter += 1  # 增加计数器，表示已经处理过一个人脸了（但不再保存图片）
    # 显示图像（但不再保存图片）
    cv2.imshow('Face Detection', frame)  # 但不再保存图片）
    if cv2.waitKey(1) & 0xFF == ord(' '):  # 按“q”键退出循环（但不再保存图片）
        break  # 释放视频和窗口资源（但不再保存图片）

import cv2
import dlib
#这个可以 显示脸部68点

# 加载面部检测器和特征点预测器
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat")
# 加载视频
video_capture = cv2.VideoCapture(0)
while True:
    # 读取视频帧
    ret, frame = video_capture.read()
    # 将帧转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # 检测人脸
    faces = detector(gray)
    for face in faces:
        # 预测特征点
        landmarks = predictor(gray, face)
        # 绘制特征点
        for n in range(0, 68):
            x = landmarks.part(n).x
            y = landmarks.part(n).y
            cv2.circle(frame, (x, y), 1, (0, 255, 0), -1)
 #       for n in range(0, 68):
 #           x = landmarks.part(n).x
#            y = landmarks.part(n).y
            # 添加序号
  #          text = str(n)
  #          cv2.putText(frame, text, (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (125, 0, 0), 1)  # 蓝字
  #          cv2.circle(frame, (x, y), 1, (0, 255, 0), -1)  # 绿圈





        # 绘制人脸框
        x = face.left()
        y = face.top()
        w = face.width()
        h = face.height()
        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

    # 显示结果
    cv2.imshow('Video', frame)

    # 按下 'q' 键退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
video_capture.release()
cv2.destroyAllWindows()

import dlib
import cv2
import numpy as np
import imutils
from imutils import face_utils
from imageio import imread
import time

predictor_path = 'shape_predictor_68_face_landmarks.dat'
face_rec_model_path = 'dlib_face_recognition_resnet_model_v1.dat'

predictor = dlib.shape_predictor(predictor_path)
detector = dlib.get_frontal_face_detector()
facerec = dlib.face_recognition_model_v1(face_rec_model_path)

(noseStart, noseEnd) = face_utils.FACIAL_LANDMARKS_IDXS["nose"]

threshold = 0.12


def get_feature(path):
    img = imread(path)
    frame = img
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    dets = detector(gray, 0)
    # print('检测到了 %d 个人脸' % len(dets))
    # 这里假设每张图只有一个人脸
    shape = predictor(gray, dets[0])
    face_vector = facerec.compute_face_descriptor(img, shape)
    return face_vector


def distance(a, b):
    a, b = np.array(a), np.array(b)
    sub = np.sum((a - b) ** 2)
    add = (np.sum(a ** 2) + np.sum(b ** 2)) / 2.
    r = sub / add
    return r


faces = None
cap = None
success = None
events = []


def init():
    global faces
    global cap
    global success
    faces = [
        (get_feature('2.jpg'), 'McKay')
    ]

    cap = cv2.VideoCapture(0)
    success, img = cap.read()


def start():
    global faces
    global cap
    global success
    while success:
        success, img = cap.read()
        frame = imutils.resize(img, width=300)
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        rects = detector(gray, 0)
        for rect in rects:
            shape = predictor(gray, rect)

            process_face_id(faces, frame, rect, shape)

            shape = face_utils.shape_to_np(shape)
            nose = shape[noseStart:noseEnd]
            noseHull = cv2.convexHull(nose)
            cv2.drawContours(frame, [noseHull], -1, (0, 255, 0), 1)
            cv2.putText(frame, "nose", (nose[0][0], nose[0][1]), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)

        cv2.imshow("Frame", frame)
        key = cv2.waitKey(1) & 0xFF

    cv2.destroyAllWindows()


def process_face_id(faces, frame, rect, shape):
    found_face_id = 'Unknown'
    if len(faces) > 0:
        face_descriptor = facerec.compute_face_descriptor(frame, shape)
        min_face_id = found_face_id
        min_face_distance = 1
        for face_feature, face_id in faces:
            cur_distance = distance(face_feature, face_descriptor)
            if cur_distance < min_face_distance:
                min_face_distance = cur_distance
                min_face_id = face_id

        if min_face_distance < threshold:
            found_face_id = min_face_id
    cv2.rectangle(frame, (rect.left(), rect.top() + 10), (rect.right(), rect.bottom()), (0, 255, 0), 2)
    cv2.putText(frame, found_face_id, (rect.left(), rect.top()), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2,
                cv2.LINE_AA)
    if found_face_id != 'Unknown':
        events.append(('user_found', found_face_id, time.time()))

import cv2
import numpy as np
# 加载级联分类器



# 加载视频

import cv2
import numpy as np

# 加载级联分类器和眼睛分类器
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')

# 加载视频
video_capture = cv2.VideoCapture(0)

# 用于存储已知人脸的特征向量和姓名
known_faces = []
known_names = []


person_counter = 1  # 计数器，用于为每个新的人脸分配一个唯一的名称

while True:
    # 读取视频帧
    ret, frame = video_capture.read()

    # 将帧转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

    for (x, y, w, h) in faces:
        # 绘制人脸框
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

        # 提取面部轮廓特征
        face_roi = gray[y:y+h, x:x+w]
        face_contour = cv2.Canny(face_roi, 100, 200)

        # 检测眼睛
        eyes = eye_cascade.detectMultiScale(face_roi)

        # 针对每个眼睛，绘制矩形框并计算特征向量
        for (ex, ey, ew, eh) in eyes:
            cv2.rectangle(frame, (x+ex, y+ey), (x+ex+ew, y+ey+eh), (255, 0, 0), 2)

            # 提取眼睛位置特征
            eye_position = [(ex + ew//2) / w, (ey + eh//2) / h]

        # 结合面部轮廓和眼睛位置特征作为人脸的特征向量
        face_vector = np.concatenate((face_contour.flatten(), eye_position))

        # 进行人脸匹配，判断是否为已知人脸
        match = False
        for i in range(len(known_faces)):
            known_face = known_faces[i]

            # 调整特征向量的大小以匹配
            if len(known_face) > len(face_vector):
                known_face = known_face[:len(face_vector)]
            else:
                face_vector = face_vector[:len(known_face)]

            distance = np.linalg.norm(face_vector - known_face)
            if distance < 100:  # 设置一个阈值来判断是否为同一个人
                match = True
                name = known_names[i]
                break

        # 如果不是已知人脸，则标记为新的人脸
        if not match:
            name = "person-" + str(person_counter)
            person_counter += 1
            known_faces.append(face_vector)
            known_names.append(name)

        # 在人脸框上显示姓名
        cv2.putText(frame, name, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

    # 显示结果
    cv2.imshow('Video', frame)

    # 按下 'q' 键退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
video_capture.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# 加载级联分类器
#face_cascade = cv2.CascadeClassifier('path_to_face_cascade.xml')
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
# 加载视频
video_capture = cv2.VideoCapture(0)

# 用于存储已知人脸的特征向量和姓名
known_faces = []
known_names = []

person_counter = 1  # 计数器，用于为每个新的人脸分配一个唯一的名称

while True:
    # 读取视频帧
    ret, frame = video_capture.read()

    # 将帧转换为灰度图像
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 检测人脸
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

    for (x, y, w, h) in faces:
        # 绘制人脸框
        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)

        # 对人脸进行特征提取（这里假设使用人脸区域作为特征向量）
        face_roi = gray[y:y+h, x:x+w]
        face_vector = face_roi.flatten()  # 将二维图像展平成一维向量

        # 进行人脸匹配，判断是否为已知人脸
        match = False
        for i in range(len(known_faces)):
            known_face = known_faces[i]
            smaller_vector = face_vector if len(face_vector) < len(known_face) else known_face
            distance = np.linalg.norm(smaller_vector - known_face[:len(smaller_vector)])
            if distance < 100:  # 设置一个阈值来判断是否为同一个人
                match = True
                name = known_names[i]
                break

        # 如果不是已知人脸，则标记为新的人脸
        if not match:
            name = "person-" + str(person_counter)
            person_counter += 1
            known_faces.append(face_vector)
            known_names.append(name)

        # 在人脸框上显示姓名
        cv2.putText(frame, name, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)

    # 显示结果
    cv2.imshow('Video', frame)

    # 按下 'q' 键退出
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# 释放资源
video_capture.release()
cv2.destroyAllWindows()

#导入cv模块
import cv2 as cv
#检测函数
def face_detect_demo(img):
    gary = cv.cvtColor(img,cv.COLOR_BGR2GRAY)

    face_detect = cv.CascadeClassifier('haarcascade_frontalface_alt2.xml')
    face = face_detect.detectMultiScale(gary)
    for x,y,w,h in face:
        cv.rectangle(img,(x,y),(x+w,y+h),color=(0,0,255),thickness=2)
    cv.imshow('result',img)
 
#读取摄像头
cap = cv.VideoCapture(0)

#cap = cv.VideoCapture('1.mp4')
#循环
while True:
    flag,frame = cap.read()
    if not flag:
        break
    face_detect_demo(frame)
    if ord(' ') == cv.waitKey(1):
        break
#释放内存
cv.destroyAllWindows()
#释放摄像头
cap.release()
 

import cv2
import os
import urllib
import urllib.request


#加载训练数据集文件
recogizer=cv2.face.LBPHFaceRecognizer_create()
recogizer.read('trainer/trainer.yml')
names=[]
warningtime = 0

def md5(str):
    import hashlib
    m = hashlib.md5()
    m.update(str.encode("utf8"))
    return m.hexdigest()

statusStr = {
    '0': '短信发送成功',
    '-1': '参数不全',
    '-2': '服务器空间不支持,请确认支持curl或者fsocket,联系您的空间商解决或者更换空间',
    '30': '密码错误',
    '40': '账号不存在',
    '41': '余额不足',
    '42': '账户已过期',
    '43': 'IP地址限制',
    '50': '内容含有敏感词'
}


def warning():
    smsapi = "马上使用更好的短信服务-短信宝官网"
    # 短信平台账号
    user = '13******10'
    # 短信平台密码
    password = md5('*******')
    # 要发送的短信内容
    content = '【报警】\n原因：检测到未知人员\n地点：xxx'
    # 要发送短信的手机号码
    phone = '*******'

    data = urllib.parse.urlencode({'u': user, 'p': password, 'm': phone, 'c': content})
    send_url = smsapi + 'sms?' + data
    response = urllib.request.urlopen(send_url)
    the_page = response.read().decode('utf-8')
    print(statusStr[the_page])

#准备识别的图片
def face_detect_demo(img):
    gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)#转换为灰度
    face_detector=cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
    face=face_detector.detectMultiScale(gray,1.1,5,cv2.CASCADE_SCALE_IMAGE,(100,100),(300,300))
    #face=face_detector.detectMultiScale(gray)
    for x,y,w,h in face:
        cv2.rectangle(img,(x,y),(x+w,y+h),color=(0,0,255),thickness=2)
        cv2.circle(img,center=(x+w//2,y+h//2),radius=w//2,color=(0,255,0),thickness=1)
        # 人脸识别
        ids, confidence = recogizer.predict(gray[y:y + h, x:x + w])
        #print('标签id:',ids,'置信评分：', confidence)
        if confidence > 80:
            global warningtime
            warningtime += 1
            if warningtime > 100:
              # warning()
               print(ids)
               warningtime = 0
            cv2.putText(img, 'unkonw', (x + 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 1)
        else:
            cv2.putText(img,str(names[ids-1]), (x + 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 1)
    cv2.imshow('result',img)
    #print('bug:',ids)

def name():
    path = './ov/'
    #names = []
    imagePaths=[os.path.join(path,f) for f in os.listdir(path)]
    for imagePath in imagePaths:
       name = str(os.path.split(imagePath)[1].split('.',2)[1])
       names.append(name)

cap=cv2.VideoCapture(0)
#cap=cv2.VideoCapture('1.mp4')
name()
while True:
    flag,frame=cap.read()
    if not flag:
        break
    face_detect_demo(frame)
    if ord(' ') == cv2.waitKey(10):
        break
cv2.destroyAllWindows()
cap.release()

import cv2
import numpy as np
import os
# coding=utf-8
import urllib
import urllib.request
import hashlib

# 加载训练数据集文件
recogizer = cv2.face.LBPHFaceRecognizer_create()
recogizer.read('trainer/trainer.yml')
names = []
warningtime = 0


# 准备识别的图片
def face_detect_demo(img):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换为灰度
    face_detector = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
    face = face_detector.detectMultiScale(gray, 1.1, 5, cv2.CASCADE_SCALE_IMAGE, (100, 100), (300, 300))
    # face=face_detector.detectMultiScale(gray)
    for x, y, w, h in face:
        cv2.rectangle(img, (x, y), (x + w, y + h), color=(0, 0, 255), thickness=2)
        cv2.circle(img, center=(x + w // 2, y + h // 2), radius=w // 2, color=(0, 255, 0), thickness=1)
        # 人脸识别
        ids, confidence = recogizer.predict(gray[y:y + h, x:x + w])
        # print('标签id:',ids,'置信评分：', confidence)
        if confidence > 80:
            cv2.putText(img, '未标名', (x + 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 1)
        else:
            cv2.putText(img, str(names[ids - 1]), (x + 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 1)
    cv2.imshow('result', img)
    # print('bug:',ids)


def name():
    path = './pic/'
    # names = []
    imagePaths = [os.path.join(path, f) for f in os.listdir(path)]
    for imagePath in imagePaths:
        name = str(os.path.split(imagePath)[1].split('.', 2)[1])
        names.append(name)


#cap = cv2.VideoCapture('http://192.168.253.7')
cap = cv2.VideoCapture(0)
#cap = cv2.VideoCapture('1.mp4')

name()
while True:
    flag, frame = cap.read()
    if not flag:
        break
    face_detect_demo(frame)
    if ord(' ') == cv2.waitKey(10):
        break
cv2.destroyAllWindows()
cap.release()
# print(names)

import os
import cv2
from PIL import Image
import numpy as np
 
def getImageAndLabels(path):
    facesSamples = []
    ids = []
    imagePaths=[os.path.join(path,f) for f in os.listdir(path)]
    # 检测人脸
    face_detector = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
    # 打印数组imagePaths
    print('数据排列：',imagePaths)
    # 遍历列表中的图片
    for imagePath in imagePaths:
        #打开图片,黑白化
        PIL_img=Image.open(imagePath).convert('L')
        #将图像转换为数组，以黑白深浅
       # PIL_img = cv2.resize(PIL_img, dsize=(400, 400))
        img_numpy=np.array(PIL_img,'uint8')
        #获取图片人脸特征
        faces = face_detector.detectMultiScale(img_numpy)
        #获取每张图片的id和姓名
        id = int(os.path.split(imagePath)[1].split('.')[0])
        #预防无面容照片
        for x,y,w,h in faces:
            ids.append(id)
            facesSamples.append(img_numpy[y:y+h,x:x+w])
        #打印脸部特征和id
        #print('fs:', facesSamples)
        print('id:', id)
        #print('fs:', facesSamples[id])
    print('fs:', facesSamples)
    #print('脸部例子：',facesSamples[0])
    #print('身份信息：',ids[0])
    return facesSamples,ids
 
if __name__ == '__main__':
    #图片路径
    path='./ov/'
    #获取图像数组和id标签数组和姓名
    faces,ids=getImageAndLabels(path)
    #获取训练对象
    recognizer=cv2.face.LBPHFaceRecognizer_create()
    #recognizer.train(faces,names)#np.array(ids)
    recognizer.train(faces,np.array(ids))
    #保存文件
    recognizer.write('./trainer/trainer.yml')
    #save_to_file('names.txt',names)