Notas de estudo de início rápido de Visão Computacional

Uma grande causa precisa de uma grande teoria para guiar o código sem teoria é um hooligan

I. Visão Geral da Inteligência Artificial

Teste de Turing: Em 1950, Turing propôs o teste de Turing, ou seja, uma pessoa conduz uma série de perguntas e respostas com a outra parte de forma especial sem tocar na outra parte. humano ou um computador, então pode-se considerar que o computador possui a mesma inteligência que um humano, ou seja, o computador pode pensar.
Diz-se que as máquinas que passam no teste de Turing têm " inteligência humana ", e até agora nenhum dispositivo de inteligência artificial passou no teste de Turing.
Conferência de Dartmouth: 1956 é o primeiro ano da inteligência artificial.
Inteligência Artificial: Pode-se dizer que máquinas e programas alcançam inteligência artificial se exibirem habilidades semelhantes às humanas em aprendizado ou não.

2. Aprendizado de Máquina

Aprendizado de máquina: é analisar automaticamente o modelo a partir dos dados e usar o modelo para fazer previsões sobre os dados desconhecidos. ( Dados e recursos determinam o limite superior do aprendizado de máquina, e modelos e algoritmos apenas se aproximam desse limite superior )
Fluxo de trabalho de aprendizado de máquina:
- 1. Obtenha dados
- 2. Processamento básico de dados
- 3. Engenharia de recursos
- 4. Aprendizado de máquina (treinamento de modelo)
- 5. Avaliação do Modelo
  - O resultado atende aos requisitos e o serviço é lançado
  - Se os requisitos não forem atendidos, repita as etapas acima
A relação entre aprendizado de máquina e inteligência artificial: O aprendizado de máquina é uma maneira de alcançar a inteligência artificial.

3. Noções básicas de iconografia

Modelo de cores RGB: Também conhecido como modelo de cores RGB ou modelo de cores vermelho, verde e azul, é um modelo de cores aditivas.
- (O princípio das três cores primárias não é por razões físicas, mas por razões fisiológicas.)
Modo de exibição do computador: modo de 24 bits (8, 8, 8) - usa três inteiros sem sinal de 8 bits (0 a 255) para representar as intensidades de vermelho, verde e azul. ( Para OpenCV, a ordem dos três canais é BGR em vez de RGB ).
- Representação de pixels em computadores: uma lista encadeada [0,0,255]
- Representação da linha central do computador: matriz de lista vinculada bidimensional [[0,0,255],[0,0,255]]
- Representação da superfície no computador: array de lista encadeada tridimensional [
  [[0,0,255],[0,0,255]], //vermelho
  [[255,0,0],[255,0,0]], // azul
  [[0,255,0],[0,255,0]], //verde
  ]
O código para instalar a biblioteca OpenCV: pip install opencv-python (se for muito lento, você pode substituir a fonte do espelho doméstico, como Douban, você pode usar o comando -i https://pypi.douban.com/simple )
Código para importar a biblioteca OpenCV: import cv2
Representação de imagens coloridas no computador: Uma matriz ou lista tridimensional pode simplesmente representar as imagens coloridas no computador.
Representação de imagens em tons de cinza em computadores: Um array bidimensional pode ser usado para representar imagens em tons de cinza, e o uso de imagens em tons de cinza pode reduzir a dimensionalidade e facilitar o processamento rápido do computador.

4. Visão Computacional e Internet das Coisas

A visão computacional é uma simulação da visão biológica usando computadores e equipamentos relacionados. Sua principal tarefa é obter informações tridimensionais da cena correspondente processando as fotos ou vídeos coletados, assim como os humanos e muitas outras criaturas fazem todos os dias. A visão computacional é o estudo de como usar câmeras e computadores para obter os dados e informações que precisamos sobre o assunto que está sendo fotografado. Em sentido figurado, é instalar olhos (câmeras) e cérebros (algoritmos) no computador, para que o computador possa perceber o ambiente.
- Simplificando, a visão computacional é uma ciência que estuda como fazer as máquinas "ver" e "entender" Seu desenvolvimento passou por um processo que vai desde a visão e compreensão até o reconhecimento e compreensão.
A Internet das Coisas (IOT) refere-se à coleta em tempo real de qualquer informação que precise ser monitorada, conectada e interagida por meio de vários dispositivos e tecnologias, como sensores de informação, tecnologia de identificação por radiofrequência, sistemas de posicionamento global, sensores infravermelhos e scanners a laser. Um objeto ou processo coleta várias informações necessárias, como som, luz, calor, eletricidade, mecânica, química, biologia, localização, etc., e realiza a conexão onipresente entre objetos e objetos e entre objetos e pessoas através de várias redes possíveis Acesso, percepção inteligente, identificação e gestão de itens e processos. A Internet das Coisas é um portador de informação baseado na Internet, redes de telecomunicações tradicionais, etc. Ela permite que todos os objetos físicos comuns que podem ser endereçados independentemente para formar uma rede interconectada.
- Com o desenvolvimento da Internet e da tecnologia de chip, podemos instalar chips e sistemas de software em muitos dispositivos e conectar-nos à Internet, na verdade a chamada Internet das Coisas, que é o conceito de vinho velho em garrafas novas.

5. Casos de Reconhecimento Facial na Prática

1. Instale os pacotes necessários

pip instalar cmake
pip instalar scikit-image
pip instalar dlib
pip instalar face_recognition

Se não houver erro vermelho durante a instalação, espere pacientemente. Em geral, se sua rede estiver OK, a instalação será bem sucedida (pode haver alguns erros ao instalar o dlib, você pode resolver sozinho, se não houver erro , espere mais).

2. As etapas do reconhecimento facial

Localize o rosto da pessoa e enquadre o rosto da pessoa com uma moldura verde;
Leia nomes e características faciais do banco de dados;
Combine as características faciais da pessoa fotografada com as características faciais do banco de dados e identifique-as com o nome do usuário;
Localize e bloqueie a tarefa de destino e use a moldura vermelha para enquadrar a face da tarefa de destino.

3. Código completo com comentários

# 总体任务
# 一： 打开摄像头，读取摄像头拍摄到的画面
# 定位到画面中的人脸，并用绿色框框出,并标识姓名

# 二： 读取数据库中的人名和面部特征

# 三： 用拍摄到人的脸部特征和数据库中的面部特征匹配
# 在用户头像的绿框上标识出用户的姓名，未知用户统一用Unknown

# 四： 定位和锁定目标人物，并用红色框把目标人物的脸部框住

import os
import cv2

import face_recognition

# 1. 准备工作
face_dataset = 'dataset'
user_names = []  # 存用户姓名
user_faces_encodings = []  # 存用户面部特征向量（与姓名一一对应）
target_names = ['ZhangWei','zhangwei','Zhang Yida']
# 2. 正式工作
# 2.1 得到dataset文件夹下所有的文件名
files = os.listdir('dataset')
# 2.2 循环读取文件名进行进一步的处理
for image_name in files:
    # 2.2.1 截取文件名作为用户名存入user_names的列表中
    user_name, _ = os.path.splitext(image_name)
    user_names.append(user_name)
    # 2.2.2 读取图片文件中的面部特征信息存入users_faces_encodings列表中
    image_file_name = os.path.join(face_dataset, image_name)
    image_file = face_recognition.load_image_file(image_file_name)
    face_encoding = face_recognition.face_encodings(image_file)[0]
    user_faces_encodings.append(face_encoding)

# 1. 打开摄像头，获取摄像头对象
cap = cv2.VideoCapture(0)  # 0代表第一个摄像头
cap.set(5,30)
# 2. 循环不停地去获取摄像头拍摄到的画面，并做进一步的处理
while True:
    # 2.1 获取摄像头拍摄到的画面
    ret, img = cap.read()
    # 2.2 从拍摄到的画面中提取出人的脸部所在区域（可能会有多个）
    # 2.2.1 返回识别到的人脸的位置（对角线两点确定一个矩形）
    # face_locations = ['第一个人脸所在的区域', '第二个人脸所在的区域', ...]
    face_locations = face_recognition.face_locations(img)
    # 2.2.2 从所有人的头像所在区域提取面部特征
    # face_encodings = ['第一个人的面部特征', '第二个人的面部特征', ...]
    face_encodings = face_recognition.face_encodings(img, face_locations)
    # 2.2.3 定义用于存储拍摄到的用户的姓名的列表，并遍历face_encodings, 和之前数据库中面部特征做匹配
    # names = ['第一个人的姓名', '第二个人的姓名', ...]
    names = []
    for face_encoding in face_encodings:
        # compare_faces(['面部特征1', '面部特征2', ...], 未知的面部特征)，返回一个数组，在匹配的地方是True，不匹配的地方是False
        matchs = face_recognition.compare_faces(user_faces_encodings, face_encoding)
        name = 'Unknown'
        for index, is_match in enumerate(matchs):
            if is_match:
                name = user_names[index]
                break
        names.append(name)
    # 2.3 循环遍历人的脸部所在的区域，并画框（颜色BGR格式，最后一个参数为线条粗细），标识人的姓名
    # zip (['第一个人的位置', '第二个人的位置',...], ['第一个人的姓名', '第二个人的姓名',...])，在遍历时会一一对应起来遍历
    for (top, right, bottom, left), name in zip(face_locations, names):
        color = (0, 255, 0)  # 默认绿色框加绿色标识
        if name in target_names:
            color = (0, 0, 255)  # 目标人物红色框加红色标识
        cv2.rectangle(img, (left, top), (right, bottom), color, 2)
        font = cv2.FONT_HERSHEY_DUPLEX
        cv2.putText(img, name, (left, top-10), font, 0.5, color, 1)
    # 2.4 通过OpenCV将拍摄到的并画了框的画面展示出来
    cv2.imshow("video_image", img)
    # 2.5 设定按下'q'键（英文输入法下的小写）退出循环，ord()返回对应字符的ASCII码
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
# 3. 退出程序的时候，释放摄像头并关闭所有窗口
cap.release()
cv2.destroyAllWindows()

4. Demonstração do resultado final

A câmera pode ser exibida em tempo real. Quanto mais fotos no banco de dados, mais recursos e mais precisos serão os resultados de reconhecimento.

6. Combate à caixa do sensor de movimento

1. Usando o método diferencial para detectar objetos em movimento

O princípio do método da diferença:

O método de diferença de quadro é um dos métodos de detecção e segmentação de objetos em movimento mais comumente usados. Primeiro, a imagem de diferença é obtida subtraindo os valores de pixel correspondentes de imagens de quadros adjacentes e, em seguida, a imagem de diferença é binarizada. Sob a circunstância de que o brilho do ambiente não muda muito, se a alteração do valor de pixel correspondente for menor do que o limiar predeterminado, pode-se considerar que isso Se o valor do pixel da área da imagem mudar muito, pode-se considerar que isso é causado por objetos em movimento na imagem. Essas áreas são marcadas como pixels de primeiro plano e a área de pixel marcada pode ser usado para determinar a posição do objeto em movimento na imagem. Como o intervalo de tempo entre dois quadros adjacentes é muito curto, usar a imagem do quadro anterior como modelo de plano de fundo do quadro atual tem melhor desempenho em tempo real, o plano de fundo não se acumula e a velocidade de atualização é rápida, o algoritmo é simples, e o valor do cálculo é pequeno. A desvantagem do algoritmo é que ele é mais sensível ao ruído ambiental, e a seleção do limiar é muito crítica. Se a seleção for muito baixa, não basta suprimir o ruído na imagem, e se for muito alto , as alterações úteis na imagem são ignoradas. Para um alvo em movimento relativamente grande com a mesma cor, pode haver furos dentro do alvo e o alvo em movimento não pode ser completamente extraído. Só funciona quando a câmera está parada.

2. Prepare a conta de teste da plataforma pública WeChat e instale as solicitações da biblioteca HTTP

(1) Visite o site da plataforma pública WeChat https://mp.weixin.qq.com
(2) Documentação de desenvolvimento de ID de serviço
(3) Iniciar o desenvolvimento -> solicitar o número de teste de interface -> entrar no sistema de aplicativo de número de teste de conta pública do WeChat
(4) Digitalize o código para fazer login
(5) Instalar solicitações de biblioteca HTTP: solicitações de instalação de pip

3. Escreva um módulo de código para o WeChat enviar notificações

import json

import requests


class WxTools():

    def __init__(self, myappid, myappsecret):
        self.app_id = myappid
        self.app_secret = myappsecret

    # 1. 获取access_token
    # https请求方式： GET https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET
    def get_access_token(self):
        url = f'https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={self.app_id}&secret={self.app_secret}'
        resp = requests.get(url).json()
        access_token = resp.get('access_token')
        return access_token

    # 2. 利用access_token发送微信的通知
    # http请求方式: POST https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=ACCESS_TOKEN
    def send_wx_customer_msg(self, open_id, msg="有人闯进了你的家"):
        url = f'https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token={self.get_access_token()}'
        req_data = {
    
    
            "touser": open_id,
            "msgtype": "text",
            "text":
            {
    
    
                 "content": msg
            }
        }
        requests.post(url, data=json.dumps(req_data, ensure_ascii=False).encode('utf-8'))


if __name__ == "__main__":
    myAppId = 'wx810664b7b6822792'  # 请改成自己得到的appID
    myAppSecret = 'bda74affba1edb48bcc7b882fd2e4369'   # 请改成自己得到的appsecret
    myOpenID = 'o6h6p5xY9ZiPRH80GcgRzTIHXjk0'   # 请改成自己的openID
    wx_tools = WxTools(myAppId, myAppSecret)  # 实例化对象并初始化
    wx_tools.send_wx_customer_msg(myOpenID)  # 调用函数进行消息的发送，如果想发送不同的消息请加上参数msg的内容

4. Escreva o código para detecção de movimento

import cv2
import datetime

from wx_notice import WxTools


cap = cv2.VideoCapture(0)
background = None  # 指定背景，作为第一幅画面进行差分法的比较
es = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 4))
is_send_msg = False  # 定义一个标志，当已经发送过通知后就不再继续发送通知了，即探测到运动物体只发送一次通知

myAppId = 'wx810664b7b6822792'  # 请改成自己得到的appID
myAppSecret = 'bda74affba1edb48bcc7b882fd2e4369'   # 请改成自己得到的appsecret
myOpenID = 'o6h6p5xY9ZiPRH80GcgRzTIHXjk0'   # 请改成自己的openID

while True:
    ret, img = cap.read()

    # 将摄像头拍摄到的画面转换为灰度图像，并使用高斯滤波消除图像中的噪声
    gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    gray_img = cv2.GaussianBlur(gray_img, (25, 25), 3)

    if background is None:
        background = gray_img
        continue

    diff = cv2.absdiff(background, gray_img)    # 应用差分法求背景图和灰度图的差
    diff = cv2.threshold(diff, 50, 255, cv2.THRESH_BINARY)[1]  # 设置阈值即50，差的小于50即算一样，255代表不同的部分以白色表示
    # cv2.dilate(src, kernel, iteration)
    # 参数说明: src表示输入的图片， kernel表示方框的大小， iteration表示迭代的次数
    # 膨胀操作原理：存在一个kernel，在图像上进行从左到右，从上到下的平移，如果方框中存在白色，那么这个方框内所有的颜色都是白色
    diff = cv2.dilate(diff, es, iterations=3)  # 做形态学膨胀使前景物体放大，即小的裂缝变小看上去会更加连续

    # cv2.findContours(image, mode, method, contours=None, hierarchy=None, offset=None)
    # image 代表输入的图片。注意输入的图片必须为二值图片。若输入的图片为彩色图片，必须先进行灰度化和二值化。
    # mode 表示轮廓的检索模式，有4种：
    # cv2.RETR_EXTERNAL 表示只检测外轮廓。
    # cv2.RETR_LIST 检测的轮廓不建立等级关系。
    # cv2.RETR_CCOMP 建立两个等级的轮廓，上面的一层为外边界，里面的一层为内孔的边界信息。如果内孔内还有一个连通物体，这个物体的边界也在顶层。
    # cv2.RETR_TREE 建立一个等级树结构的轮廓。
    # method为轮廓的近似办法，有4种：
    # cv2.CHAIN_APPROX_NONE 存储所有的轮廓点，相邻的两个点的像素位置差不超过1，即max（abs（x1 - x2），abs（y2 - y1）） <= 1。
    # cv2.CHAIN_APPROX_SIMPLE 压缩水平方向，垂直方向，对角线方向的元素，只保留该方向的终点坐标，例如一个矩形轮廓只需4个点来保存轮廓信息。
    # cv2.CHAIN_APPROX_TC89_L1和cv2.CHAIN_APPROX_TC89_KCOS使用teh - Chinlchain近似算法。
    # 函数返回两个值，一个是轮廓本身contours，还有一个是每条轮廓对应的属性hierarchy。
    contours, hierarchy = cv2.findContours(diff.copy(), cv2.RETR_EXTERNAL,
                                           cv2.CHAIN_APPROX_SIMPLE)
    is_detected = False
    for c in contours:
        # 轮廓区域>2000才认为探测到动的物体
        if cv2.contourArea(c) < 2000:
            continue
        (x, y, w, h) = cv2.boundingRect(c)
        cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)
        is_detected = True
        if not is_send_msg:
            is_send_msg = True
            wx_tools = WxTools(myAppId, myAppSecret)
            wx_tools.send_wx_customer_msg(myOpenID, '有人闯入了你的家，请留意')

    if is_detected:
        show_text = "Motion: Detected"
        show_color = (0, 0, 255)  # 探测到显示红色以及探测到
    else:
        show_text = "Motion: Undetected"
        show_color = (0, 255, 0)  # 未探测到显示绿色以及未探测到

    # 在左上角显示当前探测状态（图像、文本、坐标、字体、字体大小、颜色、线条宽度）
    cv2.putText(img, show_text, (10, 20),
                cv2.FONT_HERSHEY_SIMPLEX, 0.5, show_color, 2)
    # 在左下角显示当前时间（图像、文本、坐标、字体、字体大小、颜色、线条宽度）
    cv2.putText(img,
                datetime.datetime.now().strftime("%A %d %B %Y %I:%M:%S%p"),
                (10, img.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX,
                0.35, show_color, 1)

    cv2.imshow('video', img)
    cv2.imshow('diff', diff)

    key = cv2.waitKey(1) & 0xFFf
    if key == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

5. Demonstração do efeito de corrida

borda do computador:

Terminal móvel:

Uma coisa a notar é que a imagem de fundo da detecção é a foto capturada pela câmera no início, então tente garantir que a foto inicial não seja muito clara ou muito escura, o que afetará a detecção subsequente.

Introdução à Visão Computacional e Notas de Estudo