Notas de estudio de inicio rápido de Computer Vision

Una gran causa necesita una gran teoría para guiar el código sin teoría es un hooligan

I. Descripción general de la inteligencia artificial

Prueba de Turing: En 1950, Turing propuso la prueba de Turing, es decir, una persona realiza una serie de preguntas y respuestas con la otra parte de una manera especial sin tocar a la otra parte.Si la pregunta es para determinar si la otra parte es un humano o una computadora, entonces se puede considerar que la computadora tiene la misma inteligencia que un humano, es decir, la computadora puede pensar.
Se dice que las máquinas que pasan la prueba de Turing tienen " inteligencia humana ", y hasta ahora ningún dispositivo de inteligencia artificial ha pasado la prueba de Turing.
Conferencia de Dartmouth: 1956 es el primer año de la inteligencia artificial.
Inteligencia artificial: se puede decir que las máquinas y los programas logran inteligencia artificial si exhiben habilidades similares a las humanas en el aprendizaje o de otra manera.

2. Aprendizaje automático

Aprendizaje automático: consiste en analizar automáticamente el modelo a partir de los datos y utilizar el modelo para hacer predicciones sobre los datos desconocidos. ( Los datos y las características determinan el límite superior del aprendizaje automático, y los modelos y algoritmos solo se aproximan a este límite superior )
Flujo de trabajo de aprendizaje automático:
- 1. Obtener datos
- 2. Tratamiento básico de datos
- 3. Ingeniería de características
- 4. Aprendizaje automático (entrenamiento de modelos)
- 5. Evaluación del modelo
  - El resultado cumple con los requisitos y se lanza el servicio.
  - Si no se cumplen los requisitos, repita los pasos anteriores
La relación entre el aprendizaje automático y la inteligencia artificial: el aprendizaje automático es una forma de lograr la inteligencia artificial.

3. Conceptos básicos de iconografía

Modelo de color RGB: también conocido como modelo de color RGB o modelo de color rojo, verde y azul, es un modelo de color aditivo.
- (El principio de los tres colores primarios no se debe a razones físicas, sino a razones fisiológicas).
Modo de visualización de computadora: modo de 24 bits (8, 8, 8): utiliza tres números enteros sin signo de 8 bits (0 a 255) para representar las intensidades de rojo, verde y azul. ( Para OpenCV, el orden de los tres canales es BGR en lugar de RGB ).
- Representación de píxeles en computadoras: una lista enlazada [0,0,255]
- Representación de la línea central de la computadora: matriz de lista enlazada bidimensional [[0,0,255],[0,0,255]]
- Representación de la superficie en computadora: matriz de lista enlazada tridimensional [
  [[0,0,255],[0,0,255]], //red
  [[255,0,0],[255,0,0]], // azul
  [ [0,255,0],[0,255,0]], //verde
  ]
El código para instalar la biblioteca OpenCV: pip install opencv-python (si es demasiado lento, puede reemplazar la fuente del espejo doméstico, como Douban, puede usar el comando -i https://pypi.douban.com/simple )
Código para importar la biblioteca OpenCV: import cv2
Representación de imágenes en color en la computadora: una matriz o lista tridimensional puede representar simplemente las imágenes en color en la computadora.
Representación de imágenes en escala de grises en computadoras: se puede usar una matriz bidimensional para representar imágenes en escala de grises, y el uso de imágenes en escala de grises puede reducir la dimensionalidad y facilitar el procesamiento rápido por computadora.

4. Visión artificial e Internet de las cosas

La visión por computadora es una simulación de la visión biológica utilizando computadoras y equipos relacionados. Su tarea principal es obtener información tridimensional de la escena correspondiente procesando las imágenes o videos recopilados, tal como lo hacen los humanos y muchas otras criaturas todos los días. La visión por computadora es el estudio de cómo usar cámaras y computadoras para obtener los datos y la información que necesitamos sobre el sujeto que se está fotografiando. Para decirlo en sentido figurado, es instalar ojos (cámaras) y cerebros (algoritmos) en la computadora, para que la computadora pueda percibir el entorno.
- En pocas palabras, la visión artificial es una ciencia que estudia cómo hacer que las máquinas "vean" y "entiendan". Su desarrollo ha pasado por ese proceso desde ver y comprender hasta reconocer y comprender.
El Internet de las cosas (IOT) se refiere a la recopilación en tiempo real de cualquier información que deba monitorearse, conectarse e interactuar a través de varios dispositivos y tecnologías, como sensores de información, tecnología de identificación por radiofrecuencia, sistemas de posicionamiento global, sensores infrarrojos y escáneres láser Un objeto o proceso recopila diversa información requerida, como sonido, luz, calor, electricidad, mecánica, química, biología, ubicación, etc., y realiza la conexión ubicua entre objetos y objetos y entre objetos y personas a través de varias redes posibles. acceso Realice la percepción, identificación y gestión inteligente de elementos y procesos. El Internet de las cosas es un portador de información basado en Internet, las redes de telecomunicaciones tradicionales, etc. Permite que todos los objetos físicos comunes que se pueden abordar de forma independiente formen una red interconectada.
- Con el desarrollo de Internet y la tecnología de chips, podemos instalar chips y sistemas de software en muchos dispositivos y luego conectarnos a Internet. Esto es en realidad el llamado Internet de las cosas, que es el concepto de vino añejo en botellas nuevas.

5. Casos de reconocimiento facial en la práctica

1. Instale los paquetes necesarios

pip instalar cmake
pip install scikit-imagen
pip instalar dlib
instalación de pip face_recognition

Si no hay un error rojo durante la instalación, solo espere pacientemente. En general, si su red está bien, la instalación será exitosa (puede haber algunos errores al instalar dlib, puede resolverlo usted mismo, si no hay ningún error , espera más) .

2. Los pasos del reconocimiento facial

Ubique la cara de la persona y enmarque la cara de la persona con un marco verde;
Leer nombres y rasgos faciales de la base de datos;
Relacionar los rasgos faciales de la persona fotografiada con los rasgos faciales de la base de datos e identificarlos con el nombre del usuario;
Ubique y bloquee la tarea de destino y use el marco rojo para enmarcar la cara de la tarea de destino.

3. Código completo con comentarios

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

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

# 三： 用拍摄到人的脸部特征和数据库中的面部特征匹配
# 在用户头像的绿框上标识出用户的姓名，未知用户统一用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. Demostración del resultado final

La cámara se puede mostrar en tiempo real. Cuantas más imágenes haya en la base de datos, más características y más precisos serán los resultados del reconocimiento.

6. Combate de la caja del sensor de movimiento

1. Uso del método diferencial para detectar objetos en movimiento

El método del principio de la diferencia:

El método de diferencia de fotogramas es uno de los métodos de segmentación y detección de objetos en movimiento más utilizados. Primero, la imagen de diferencia se obtiene restando los valores de píxel correspondientes de las imágenes de fotogramas adyacentes, y luego la imagen de diferencia se binariza.Bajo la circunstancia de que el brillo ambiental no cambia mucho, si el cambio del valor de píxel correspondiente es menor que el umbral predeterminado, se puede considerar que esto Si el valor de píxel del área de la imagen cambia mucho, se puede considerar que es causado por objetos en movimiento en la imagen.Estas áreas se marcan como píxeles de primer plano, y el área de píxel marcada se puede utilizar para determinar la posición del objeto en movimiento en la imagen. Debido a que el intervalo de tiempo entre dos cuadros adyacentes es muy corto, usar la imagen del cuadro anterior como modelo de fondo del cuadro actual tiene un mejor rendimiento en tiempo real, el fondo no se acumula y la velocidad de actualización es rápida, el algoritmo es simple, y la cantidad de cálculo es pequeña. La desventaja del algoritmo es que es más sensible al ruido ambiental, y la selección del umbral es muy crítica, si la selección es demasiado baja, no es suficiente para suprimir el ruido en la imagen, y si es demasiado alta , los cambios útiles en la imagen se ignoran. Para un objetivo en movimiento relativamente grande con el mismo color, puede haber agujeros dentro del objetivo y el objetivo en movimiento no se puede extraer por completo. Solo funciona cuando la cámara está quieta.

2. Prepare la cuenta de prueba de la plataforma pública de WeChat e instale las solicitudes de la biblioteca HTTP

(1) Visite el sitio web de la plataforma pública de WeChat https://mp.weixin.qq.com
(2) Documentación de desarrollo de ID de servicio
(3) Iniciar el desarrollo -> solicitar el número de prueba de la interfaz -> ingresar al sistema de solicitud del número de prueba de la cuenta pública de WeChat
(4) Escanea el código para iniciar sesión
(5) Instalar solicitudes de biblioteca HTTP: solicitudes de instalación de pip

3. Escriba un módulo de código para que WeChat envíe notificaciones

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. Escriba el código para la detección de movimiento.

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. Demostración del efecto de carrera

Borde de la PC:

Terminal móvil:

Una cosa a tener en cuenta es que la imagen de fondo de la detección es la foto capturada por la cámara al principio, así que trate de asegurarse de que la foto inicial no sea demasiado brillante ni demasiado oscura, lo que afectará la detección posterior.

Visión artificial sin dolor Introducción y notas de estudio