AI 助理
备案控制台
开发者社区 人工智能 文章 正文

人脸识别实战：使用Opencv+SVM实现人脸识别

2022-01-06 592
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 在本文中，您将学习如何使用 OpenCV 进行人脸识别。文章分三部分介绍：第一，将首先执行人脸检测，使用深度学习从每个人脸中提取人脸量化为128位的向量。第二， 在嵌入基础上使用支持向量机（SVM）训练人脸识别模型。第三，最后使用 OpenCV 识别图像和视频流中的人脸。

在本文中，您将学习如何使用 OpenCV 进行人脸识别。文章分三部分介绍：

第一，将首先执行人脸检测，使用深度学习从每个人脸中提取人脸量化为128位的向量。

第二， 在嵌入基础上使用支持向量机（SVM）训练人脸识别模型。

第三，最后使用 OpenCV 识别图像和视频流中的人脸。

img

项目结构

facedetection
├─dataset
│  ├─Biden
│  ├─chenglong
│  ├─mayun
│  ├─Trump
│  ├─yangmi
│  └─zhaoliying
├─face_dete_model
│  ├─deploy.proto.txt
│  └─res10_300x300_ssd_iter_140000_fp16.caffemodel
│
├─output
├─face_embeddings.py
├─nn4.small2.v1.t7
├─recognize_face.py
├─recognize_video.py
└─train_face.py

编码

新建face_embeddings.py脚本，写入如下代码：

# import the necessary packages
import numpy as np
import pickle
import cv2
import os
import os

导入需要的包。然后定义几个函数：

def list_images(basePath, contains=None):
    # return the set of files that are valid
    return list_files(basePath, validExts=image_types, contains=contains)


def list_files(basePath, validExts=None, contains=None):
    # loop over the directory structure
    for (rootDir, dirNames, filenames) in os.walk(basePath):
        # loop over the filenames in the current directory
        for filename in filenames:
            # if the contains string is not none and the filename does not contain
            # the supplied string, then ignore the file
            if contains is not None and filename.find(contains) == -1:
                continue
            # determine the file extension of the current file
            ext = filename[filename.rfind("."):].lower()
            # check to see if the file is an image and should be processed
            if validExts is None or ext.endswith(validExts):
                # construct the path to the image and yield it
                imagePath = os.path.join(rootDir, filename)
                yield imagePath

def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    # 如果高和宽为None则直接返回
    if width is None and height is None:
        return image
    # 检查宽是否是None
    if width is None:
        # 计算高度的比例并并按照比例计算宽度
        r = height / float(h)
        dim = (int(w * r), height)
    # 高为None
    else:
        # 计算宽度比例，并计算高度
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    # return the resized image
    return resized

list_images函数，读取数据集文件夹下面的图片。

resize函数，等比例resize图片。接下来定义一些变量：

dataset_path='dataset'
embeddings_path='output/embeddings.pickle'
detector_path='face_dete_model'
embedding_model='nn4.small2.v1.t7'
confidence_low=0.5

dataset_path：数据集路径

embeddings_path：输出编码文件的路径

detector_path：人脸检测模型的路径

embedding_model：编码模型

confidence_low：最低的置信度。

接下来就是代码的最重要的部分：

print("loading face detector...")
protoPath = os.path.sep.join([detector_path, "deploy.proto.txt"])
modelPath = os.path.sep.join([detector_path,"res10_300x300_ssd_iter_140000_fp16.caffemodel"])
detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)
# 加载序列化的人脸编码模型
print("loading face recognizer...")
embedder = cv2.dnn.readNetFromTorch(embedding_model)
# 获取数据集中输入图像的路径
print("quantifying faces...")
imagePaths = list(list_images(dataset_path))
# 初始化我们提取的面部编码列表和相应的人名
knownEmbeddings = []
knownNames = []
# 初始化处理的人脸总数
total = 0
# loop over the image paths
for (i, imagePath) in enumerate(imagePaths):
    # extract the person name from the image path
    print("processing image {}/{}".format(i + 1,len(imagePaths)))
    name = imagePath.split(os.path.sep)[-2]
    # 加载图像，将其调整为宽度为 600 像素（同时保持纵横比），然后抓取图像尺寸
    image = cv2.imread(imagePath)
    image = resize(image, width=600)
    (h, w) = image.shape[:2]
    # 从图像构建一个 blob
    imageBlob = cv2.dnn.blobFromImage(
        cv2.resize(image, (300, 300)), 1.0, (300, 300),
        (104.0, 177.0, 123.0), swapRB=False, crop=False)
    # 使用 OpenCV 的基于深度学习的人脸检测器来定位输入图像中的人脸
    detector.setInput(imageBlob)
    detections = detector.forward()
    # ensure at least one face was found
    if len(detections) > 0:
        # 假设每个图像只有一张脸，所以找到概率最大的边界框
        i = np.argmax(detections[0, 0, :, 2])
        confidence = detections[0, 0, i, 2]
        # 确保最大概率的检测也意味着我们的最小概率测试（从而帮助过滤掉弱检测）
        if confidence > confidence_low:
            # 计算人脸边界框的 (x, y) 坐标
            box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
            (startX, startY, endX, endY) = box.astype("int")
            # 提取人脸ROI并抓取ROI维度
            face = image[startY:endY, startX:endX]
            (fH, fW) = face.shape[:2]
            # 确保人脸宽度和高度足够大
            if fW < 20 or fH < 20:
                continue
            # 为人脸 ROI 构造一个 blob，然后将 blob 通过我们的人脸嵌入模型来获得人脸的 128-d 量化
            faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,
                                             (96, 96), (0, 0, 0), swapRB=True, crop=False)
            embedder.setInput(faceBlob)
            vec = embedder.forward()
            # 将人名+对应的人脸嵌入添加到各自的列表中
            knownNames.append(name)
            knownEmbeddings.append(vec.flatten())
            total += 1
# 保存编码文件
print("serializing {} encodings...".format(total))
data = {"embeddings": knownEmbeddings, "names": knownNames}
f = open(embeddings_path, "wb")
f.write(pickle.dumps(data))
f.close()

加载人脸检测器和编码器：

检测器：使用基于Caffe的DL人脸检测器来定位图像中的人脸。

编码器：模型基于Torch，负责通过深度学习特征提取来提取人脸编码。

接下来，让我们抓取图像路径并执行初始化。

遍历 imagePaths。从路径中提取人名。

构造了一个 blob。

然后，通过将 imageBlob 通过检测器网络来检测图像中的人脸。

检测列表包含定位图像中人脸的概率和坐标。

假设我们至少有一个检测，将进入 if 语句的主体。

假设图像中只有一张脸，因此提取具有最高置信度的检测并检查以确保置信度满足用于过滤弱检测的最小概率阈值。

假设已经达到了这个阈值，提取面部 ROI 并抓取/检查尺寸以确保面部 ROI 足够大。

然后，我们将利用编码器 并提取人脸编码。

继续构建另一个 blob。

随后，将 faceBlob 通过编码器 。 这会生成一个 128 维向量 (vec) 来描述面部。

然后我们简单地将名称和嵌入 vec 分别添加到 knownNames 和 knownEmbeddings 中。

继续循环图像、检测人脸并为数据集中的每个图像提取人脸编码的过程。

循环结束后剩下的就是将数据转储到磁盘。

运行结果：

loading face detector...
loading face recognizer...
quantifying faces...
processing image 1/19
processing image 2/19
processing image 3/19
processing image 4/19
processing image 5/19
processing image 6/19
processing image 7/19
processing image 8/19
processing image 9/19
processing image 10/19
processing image 11/19
processing image 12/19
processing image 13/19
processing image 14/19
processing image 15/19
processing image 16/19
processing image 17/19
processing image 18/19
processing image 19/19
serializing 19 encodings...

Process finished with exit code 0

训练人脸识别模型

已经为每张脸提取了 128 维编码——但是我们如何根据这些嵌入来识别一个人呢？

答案是我们需要在嵌入之上训练一个“标准”机器学习模型（例如 SVM、k-NN 分类器、随机森林等）。

今天我们使用SVM实现

打开 train_face.py 文件并插入以下代码：

from sklearn.preprocessing import LabelEncoder
from sklearn.svm import SVC
import pickle

embeddings_path='output/embeddings.pickle'
recognizer_path='output/recognizer.pickle'
lable_path='output/le.pickle'
# 加载编码模型
print("[INFO] loading face embeddings...")
data = pickle.loads(open(embeddings_path, "rb").read())

# 给label编码
print("[INFO] encoding labels...")
le = LabelEncoder()
labels = le.fit_transform(data["names"])
# 训练用于接受人脸 128-d 嵌入的模型，然后产生实际的人脸识别
recognizer = SVC(C=1.0, kernel="linear", probability=True)
recognizer.fit(data["embeddings"], labels)
# 保存模型
f = open(recognizer_path, "wb")
f.write(pickle.dumps(recognizer))
f.close()
# 保存lable
f = open(lable_path, "wb")
f.write(pickle.dumps(le))
f.close()

导入包和模块。 我们将使用 scikit-learn 的支持向量机 (SVM) 实现，这是一种常见的机器学习模型。

定义变量。

  • embeddings_path：序列化编码。
  • recognizer_path：这将是我们识别人脸的输出模型。 它基于 SVM。
  • lable_path：标签编码器输出文件路径

加载编码。

然后初始化 scikit-learn LabelEncoder 并编码名称标签。

训练模型。本文使用的是线性支持向量机 (SVM)，但如果您愿意，您可以尝试使用其他机器学习模型进行试验。

训练模型后，我们将模型和标签编码器保存到电脑上。

运行train_face.py 脚本。

识别图像中的人脸

新建脚本文件recognize_face.py，插入一下代码：

import numpy as np
import pickle
import cv2
import os

导入包，然后我们需要新增一个resize方法。

def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    # 如果高和宽为None则直接返回
    if width is None and height is None:
        return image
    # 检查宽是否是None
    if width is None:
        # 计算高度的比例并并按照比例计算宽度
        r = height / float(h)
        dim = (int(w * r), height)
    # 高为None
    else:
        # 计算宽度比例，并计算高度
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    # return the resized image
    return resized

等比例resize图像,定义变量：

image_path = '11.jpg'
detector_path = 'face_dete_model'
embedding_path = 'nn4.small2.v1.t7'
recognizer_path = 'output/recognizer.pickle'
label_path = 'output/le.pickle'
confidence_low = 0.5

这六个变量的含义如下：

  • image_path ：输入图像的路径。
  • detector_path：OpenCV 深度学习人脸检测器的路径。 使用这个模型来检测人脸 ROI 在图像中的位置。
  • embedding_path : OpenCV 深度学习人脸编码模型的路径。 我们将使用这个模型从人脸 ROI 中提取 128 维人脸嵌入——然后将把数据输入到识别器中。
  • recognizer_path ：识别器模型的路径。
  • label_path : 标签编码器的路径。
  • confidence_low：过滤弱人脸检测的可选阈值。

接下来是代码的主体部分：

# 加载序列化人脸检测器
print("[INFO] loading face detector...")
protoPath = os.path.sep.join([detector_path, "deploy.proto.txt"])
modelPath = os.path.sep.join([detector_path,"res10_300x300_ssd_iter_140000_fp16.caffemodel"])
detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)
# 加载我们序列化的人脸编码模型
print("[INFO] loading face recognizer...")
embedder = cv2.dnn.readNetFromTorch(embedding_path)
# 加载实际的人脸识别模型和标签编码器
recognizer = pickle.loads(open(recognizer_path, "rb").read())
le = pickle.loads(open(label_path, "rb").read())
# 加载图像，将其调整为宽度为 600 像素（同时保持纵横比），然后抓取图像尺寸
image = cv2.imread(image_path)
image = resize(image, width=600)
(h, w) = image.shape[:2]
# 从图像构建一个 blob
imageBlob = cv2.dnn.blobFromImage(
    cv2.resize(image, (300, 300)), 1.0, (300, 300),
    (104.0, 177.0, 123.0), swapRB=False, crop=False)

# 应用 OpenCV 的基于深度学习的人脸检测器来定位输入图像中的人脸
detector.setInput(imageBlob)
detections = detector.forward()

# loop over the detections
for i in range(0, detections.shape[2]):
    # 提取与预测相关的置信度（即概率）
    confidence = detections[0, 0, i, 2]
    # filter out weak detections
    if confidence > confidence_low:
        # 计算人脸边界框的 (x, y) 坐标
        box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
        (startX, startY, endX, endY) = box.astype("int")
        # 提取人脸ROI
        face = image[startY:endY, startX:endX]
        (fH, fW) = face.shape[:2]
        # 确保人脸宽度和高度足够大
        if fW < 20 or fH < 20:
            continue

        # 为人脸 ROI 构造一个 blob，然后将 blob 通过我们的人脸嵌入模型来获得人脸的 128-d 量化
        faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255, (96, 96),
                                         (0, 0, 0), swapRB=True, crop=False)
        embedder.setInput(faceBlob)
        vec = embedder.forward()
        # 执行分类以识别人脸
        preds = recognizer.predict_proba(vec)[0]
        j = np.argmax(preds)
        proba = preds[j]
        name = le.classes_[j]
        # 绘制人脸的边界框以及相关的概率
        text = "{}: {:.2f}%".format(name, proba * 100)
        y = startY - 10 if startY - 10 > 10 else startY + 10
        cv2.rectangle(image, (startX, startY), (endX, endY),
                      (0, 0, 255), 2)
        cv2.putText(image, text, (startX, y),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

# 展示结果
cv2.imshow("Image", image)
cv2.waitKey(0)

我们在这个块中加载三个模型。 冒着冗余的风险，我想明确提醒您模型之间的差异：

  • 检测器：一个预训练的 Caffe DL 模型，用于检测人脸在图像中的位置。
  • embedder：一个预训练的 Torch DL 模型，用于计算我们的 128-D 人脸嵌入。
  • 识别器：线性 SVM 人脸识别模型。
    1 和 2 都是预先训练好的，这意味着它们是由 OpenCV 按原样提供给您的

加载标签编码器，其中包含我们的模型可以识别的人的姓名。

将图像加载到内存中并构建一个 blob。

通过我们的检测器定位图像中的人脸。

您将从步骤 1 中识别出此块。 我在这里再解释一遍：

遍历检测并提取每个检测的置信度。

然后将置信度与命令行 最小概率检测阈值进行比较，确保计算出的概率大于最小概率。

我们提取人脸 ROI并确保它的空间维度足够大。
下面是识别人脸 ROI代码：

首先，构建一个 faceBlob）并将其通过编码器以生成描述面部的 128 维向量

然后，我们将 vec 通过我们的 SVM 识别器模型，其结果是我们对面部 ROI 中的人的预测。

我们取最高概率指数并查询我们的标签编码器以找到名称。

循环中识别每一张脸（包括“未知”）人：

在构造了一个包含名称和概率的文本字符串。

然后在脸部周围绘制一个矩形并将文本放在框上方。

最后我们在屏幕上可视化结果，直到按下某个键。

image-20211216141212409

可以看出使用机器学习的方式准确率还是比较低的，但是优点是速度快。

摄像头识别人脸

这里我用视频代替，代码和图像中识别人脸的步骤一致，直接上代码。

新建recognize_video.py脚本，插入一下代码：

import numpy as np
import pickle
import time
import cv2
import os


def resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    dim = None
    (h, w) = image.shape[:2]
    # 如果高和宽为None则直接返回
    if width is None and height is None:
        return image
    # 检查宽是否是None
    if width is None:
        # 计算高度的比例并并按照比例计算宽度
        r = height / float(h)
        dim = (int(w * r), height)
    # 高为None
    else:
        # 计算宽度比例，并计算高度
        r = width / float(w)
        dim = (width, int(h * r))
    resized = cv2.resize(image, dim, interpolation=inter)
    # return the resized image
    return resized

out_put='output.avi'
video_path = '1.mp4'
detector_path = 'face_dete_model'
embedding_path = 'nn4.small2.v1.t7'
recognizer_path = 'output/recognizer.pickle'
label_path = 'output/le.pickle'
confidence_low = 0.5
# load our serialized face detector from disk
print("[INFO] loading face detector...")
protoPath = os.path.sep.join([detector_path, "deploy.proto.txt"])
modelPath = os.path.sep.join([detector_path,"res10_300x300_ssd_iter_140000_fp16.caffemodel"])
detector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)

# load our serialized face embedding model from disk
print("[INFO] loading face recognizer...")
embedder = cv2.dnn.readNetFromTorch(embedding_path)

# load the actual face recognition model along with the label encoder
recognizer = pickle.loads(open(recognizer_path, "rb").read())
le = pickle.loads(open(label_path, "rb").read())

# initialize the video stream, then allow the camera sensor to warm up
print("[INFO] starting video stream...")
#vs = cv2.VideoCapture(0) #摄像头
vs=cv2.VideoCapture(video_path)# 视频
time.sleep(2.0)

# start the FPS throughput estimator

writer=None
# loop over frames from the video file stream
while True:
    # grab the frame from the threaded video stream
    ret_val, frame = vs.read()

    if ret_val is False:
        break
    # resize the frame to have a width of 600 pixels (while
    # maintaining the aspect ratio), and then grab the image
    # dimensions
    frame = resize(frame, width=600)
    (h, w) = frame.shape[:2]

    # construct a blob from the image
    imageBlob = cv2.dnn.blobFromImage(
        cv2.resize(frame, (300, 300)), 1.0, (300, 300),
        (104.0, 177.0, 123.0), swapRB=False, crop=False)

    # apply OpenCV's deep learning-based face detector to localize
    # faces in the input image
    detector.setInput(imageBlob)
    detections = detector.forward()

    # loop over the detections
    for i in range(0, detections.shape[2]):
        # extract the confidence (i.e., probability) associated with
        # the prediction
        confidence = detections[0, 0, i, 2]

        # filter out weak detections
        if confidence >confidence_low:
            # 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")
            # extract the face ROI
            face = frame[startY:endY, startX:endX]
            (fH, fW) = face.shape[:2]

            # ensure the face width and height are sufficiently large
            if fW < 20 or fH < 20:
                continue

            # construct a blob for the face ROI, then pass the blob
            # through our face embedding model to obtain the 128-d
            # quantification of the face
            faceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,
                                             (96, 96), (0, 0, 0), swapRB=True, crop=False)
            embedder.setInput(faceBlob)
            vec = embedder.forward()

            # perform classification to recognize the face
            preds = recognizer.predict_proba(vec)[0]
            j = np.argmax(preds)
            proba = preds[j]
            name = le.classes_[j]

            # draw the bounding box of the face along with the
            # associated probability
            text = "{}: {:.2f}%".format(name, proba * 100)
            y = startY - 10 if startY - 10 > 10 else startY + 10
            cv2.rectangle(frame, (startX, startY), (endX, endY),
                          (0, 0, 255), 2)
            cv2.putText(frame, text, (startX, y),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.45, (0, 0, 255), 2)

            if writer is None and out_put is not None:
                fourcc = cv2.VideoWriter_fourcc(*"MJPG")
                writer = cv2.VideoWriter(out_put, fourcc, 20,
                                         (frame.shape[1], frame.shape[0]), True)
                # 如果 writer 不是 None，则将识别出人脸的帧写入磁盘
            if writer is not None:
                writer.write(frame)
    # show the output frame
    cv2.imshow("Frame", frame)
    key = cv2.waitKey(1) & 0xFF
    # if the `q` key was pressed, break from the loop
    if key == ord("q"):
        break

# do a bit of cleanup
cv2.destroyAllWindows()
vs.release()
if writer is not None:
    writer.release()

运行结果：

请添加图片描述
完整的代码：
https://download.csdn.net/download/hhhhhhhhhhwwwwwwwwww/64761335

文章标签：
计算机视觉
机器学习/深度学习
算法框架/工具
数据可视化
Caffe
关键词：
OpenCV实战
OpenCV人脸识别
实人认证svm
实人认证opencv
实人认证实战
AI浩
目录
相关文章
yantuguiguziPGJ
|
3月前
|
算法 计算机视觉
基于qt的opencv实时图像处理框架FastCvLearn实战
本文介绍了一个基于Qt的OpenCV实时图像处理框架FastCvLearn，通过手撕代码的方式详细讲解了如何实现实时人脸马赛克等功能，并提供了结果展示和基础知识回顾。
yantuguiguziPGJ
110 7
基于qt的opencv实时图像处理框架FastCvLearn实战
yantuguiguziPGJ
|
3月前
|
文字识别 计算机视觉 开发者
基于QT的OCR和opencv融合框架FastOCRLearn实战
本文介绍了在Qt环境下结合OpenCV库构建OCR识别系统的实战方法，通过FastOCRLearn项目，读者可以学习Tesseract OCR的编译配置和在Windows平台下的实践步骤，文章提供了技术资源链接，帮助开发者理解并实现OCR技术。
yantuguiguziPGJ
139 9
基于QT的OCR和opencv融合框架FastOCRLearn实战
半截诗
|
2月前
|
机器学习/深度学习 算法 计算机视觉
【Python篇】Python + OpenCV 全面实战：解锁图像处理与视觉智能的核心技能
【Python篇】Python + OpenCV 全面实战：解锁图像处理与视觉智能的核心技能
半截诗
75 2
yantuguiguziPGJ
|
3月前
|
计算机视觉
基于QT的opencv插件框架qtCvFrameLearn实战
这篇文章详细介绍了如何基于Qt框架开发一个名为qtCvFrameLearn的OpenCV插件，包括项目配置、插件加载、Qt与OpenCV图像转换，以及通过各个插件学习OpenCV函数的使用，如仿射变换、卡通效果、腐蚀、旋转和锐化等。
yantuguiguziPGJ
46 10
aliyun7689123603-22772
|
4月前
|
机器学习/深度学习 算法 机器人
用OpenCV实现人脸识别？
8月更文挑战第25天
aliyun7689123603-22772
77 2
请看我回答~
|
4月前
|
机器学习/深度学习 人工智能 监控
利用Python和OpenCV实现实时人脸识别系统
【8月更文挑战第31天】本文将引导您了解如何使用Python结合OpenCV库构建一个简易的实时人脸识别系统。通过分步讲解和示例代码，我们将探索如何从摄像头捕获视频流、进行人脸检测以及识别特定个体。本教程旨在为初学者提供一条明晰的学习路径，帮助他们快速入门并实践人脸识别技术。
请看我回答~
83 0
胖哥真不错
|
5月前
|
机器学习/深度学习 数据采集 算法
Python基于MTCNN+FaceNet+SVM进行人脸识别项目实战
Python基于MTCNN+FaceNet+SVM进行人脸识别项目实战
胖哥真不错
84 4
爱你三千遍斯塔克
|
5月前
|
机器学习/深度学习 人工智能 计算机视觉
好的资源-----打卡机+Arm+Qt+OpenCV嵌入式项目-基于人脸识别的考勤系统-----B站神经网络与深度学习，商城
好的资源-----打卡机+Arm+Qt+OpenCV嵌入式项目-基于人脸识别的考勤系统-----B站神经网络与深度学习，商城
爱你三千遍斯塔克
82 0
一-白
|
6月前
|
机器学习/深度学习 监控 算法
使用Python和OpenCV实现简单的人脸识别系统
使用Python和OpenCV实现简单的人脸识别系统
一-白
70 0
zzy的aly
|
2月前
|
计算机视觉
Opencv学习笔记(三):图像二值化函数cv2.threshold函数详解
这篇文章详细介绍了OpenCV库中的图像二值化函数`cv2.threshold`，包括二值化的概念、常见的阈值类型、函数的参数说明以及通过代码实例展示了如何应用该函数进行图像二值化处理，并展示了运行结果。
zzy的aly
393 0
Opencv学习笔记(三):图像二值化函数cv2.threshold函数详解

热门文章

最新文章

  • 1
    Python-OpenCV学习（十）用GrabCUt算法进行图片前景的提取
  • 2
    OpenCV 1 图像分割--分水岭算法代码
  • 3
    Python opencv图像处理基础总结(六) 直线检测 圆检测 轮廓发现
  • 4
    OpenCV教程(43) harris角的检测(1)
  • 5
    OpenCV中读取视频/camera代码
  • 6
    CV预备(三): Ubuntu18.04和macOS10.14.6下OpenCV3.X环境搭建
  • 7
    在Ubuntu系统上安装OpenCV C++
  • 8
    C++ 使用 opencv 库时 Point 在已经引入了 core.hpp 的情况下仍无法识别的可能原因
  • 9
    1.1.7-学习Opencv与MFC混合编程之---为画图工具添加工具栏
  • 10
    Qt, OpenCV与OpenGL协同作战：图像处理与三维图形界面的完美结合
  • 1
    LabVIEW利用矢量量化直方图开发人脸识别
    38
  • 2
    人脸识别平台批量导入绑定设备的一种方法
    67
  • 3
    JAVA语言VUE2+Spring boot+MySQL开发的智慧校园系统源码（电子班牌可人脸识别）Saas 模式
    555
  • 4
    数据分享|Python卷积神经网络CNN身份识别图像处理在疫情防控下口罩识别、人脸识别
    104
  • 5
    未来智能城市中的人脸识别技术发展趋势
    240
  • 6
    【实战项目】网络编程：在Linux环境下基于opencv和socket的人脸识别系统--C++实现
    236
  • 7
    利用深度学习技术实现人脸识别系统
    154
  • 8
    大华相机接入web页面实现人脸识别
    160
  • 9
    【PyTorch实战演练】深入剖析MTCNN(多任务级联卷积神经网络)并使用30行代码实现人脸识别
    575
  • 10
    关于人脸识别最近浏览器打不开摄像头的解决方案
    180

    • 相关课程

    更多
  • 语音识别原理与应用
  • 个性化语音合成模型微调
  • 【视觉与图像】Python+OpenCV教程基础篇
  • AI人像动漫画实操教学
  • 计算机视觉类比赛汇总

    • 相关电子书

    更多
  • 利用CNN实现无需联网的图像识别
  • 深度学习在智能视频分析和理解中的应用
  • 图像搜索与识别在大规模场景中的研究与实践

    • 相关实验场景

    更多
  • AI克隆声音，基于函数计算部署GPT-Sovits语音生成模型
  • 使用PAI-DSW x EasyPhoto快速完成AIGC人物写真生成
  • 基于函数计算一键搭建手写体OCR识别平台
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车识别路牌停车
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车多车跟随
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车综合实验
    • 下一篇
    使用阿里云接口（API）进行身份证实名认证