Necesito construir un sistema que pueda identificar a una persona procesando la imagen capturada por la cámara usando un microprocesador, ¿cuál sería el más adecuado? Dispositivos inteligentes y tecnología digital

Hicimos un proyecto similar en nuestro tercer año. Déjame explicarte todo el proyecto y te ayudará con seguridad ( Leer completamente).

Construimos un Patrol Bot (RAKSHAK) que puede usarse para vigilancia en las fronteras y áreas seguras para detectar cualquier violación de seguridad.

Hardware utilizado: utilizamos Raspberry pi como unidad de procesamiento, Arduino como unidad de control y cámara Raspberry pi. (También puede usar cámaras web simples, pero habrá algún retraso, si lo está usando para monitoreo continuo).
Plataforma utilizada: Obviamente, es Python usando bibliotecas Open CV . Open CV tiene una gran colección de funciones de procesamiento de imágenes para trabajar.
Descripción del proyecto: El objetivo principal de nuestro proyecto es construir un bot de patrulla autónomo que detecte la intrusión humana en áreas seguras y envíe la foto de la persona no autenticada a la PC remota utilizando el protocolo SMTP.

Detección y reconocimiento humanos: esta es la parte principal del proyecto. Antes de pasar a la parte de reconocimiento facial, tenemos que detectar si la imagen capturada es cara humana o no. Para eso, utilizamos la detección de rostros utilizando el algoritmo Haar Cascades. El código de Python escrito para la detección de rostros se adjunta a continuación.

importar io
importar picamera
importar os
importar cv2
importar numpy como np
importar RPi.GPIO como GPIO ## Importar biblioteca GPIO
importar tiempo ## Importar biblioteca ‘tiempo’. Nos permite usar ‘dormir’

PIN = 7 # El pin donde se supone que debe estar conectado el led, el otro extremo del led debe conectarse a través de una resistencia (la ausencia de que quema el led) a tierra (PIN 6)
# GPIO.setmode (GPIO.BOARD) ## Use la numeración del pin de la placa
# GPIO.setup (PIN, GPIO.OUT) ## Configure GPIO Pin 7 en OUT
TIEMPO = 1 #esto es el tiempo en segundos que el led debe brillar cuando se detecta movimiento

FRAME_WIDTH = 150
FRAME_HEIGHT = 150
ANCHO DE CÁMARA = 240
ALTURA_CÁMARA = 240
VIDEO_INTERVAL = 1

cam = cv2.VideoCapture (0) # Establecer parámetros de la cámara
# ejecutando los clasificadores
faceCascade = cv2.CascadeClassifier (‘haarcascade_mcs_upperbody.xml’)

def detect_human (imcolor):

haar global Cara, almacenamiento, cara Cascada
gris = cv2.cvtColor (imcolor, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale (
gris,
scaleFactor = 1.1,
minNeighbours = 5,
minSize = (2, 2),
flags = cv2.cv.CV_HAAR_SCALE_IMAGE
)
para (tlx, tly, w, h) en caras:
brx = tlx + w
bry = tly + h
borde = [tlx, tly, brx, bry]
cv2.rectangle (imcolor, (brx, bry), (tlx, tly), (0,255,0), 2)
tipo de impresión (imcolor)
volver [imcolor, borde]
return [imcolor, Ninguno]

def compare_borders (borde anterior, borde):

TIEMPO global
diff = abs (borde – borde anterior)
imprimir suma (diff)
si suma (diff)> 40:
imprimir “Movimiento detectado”
# Ahora enciende el led por ‘TIEMPO’ segundos
past_time = time.now ()
mientras cierto:
delta_time = int (time.now () – past_time)
si delta_time> TIME:
rotura
GPIO.output (PIN, GPIO.HIGH) # Enciende el led
GPIO.output (PIN, GPIO.HIGH)
time.sleep (TIME)
GPIO.output (PIN, GPIO.LOW) # LED de apagado
os.system (‘play –no-show-progress –null –channels 1 sintetizador% s seno% f’% (0.1, 700))

#Función principal
def main ():

cámara global, umbral_máx, umbral_sum, FRAME_HEIGHT, FRAME_WIDTH, i
cv2.namedWindow (“Imagen diferencial”, cv2.CV_WINDOW_AUTOSIZE)
cuenta = 0
bandera = 1
i = 0
motion_count = 1
mientras cierto:

# Crear el flujo en memoria
stream = io.BytesIO ()

con picamera.PiCamera () como cámara:
camera.resolution = (CAMERA_WIDTH, CAMERA_HEIGHT)
camera.start_preview ()
camera.capture (stream, format = ‘jpeg’)

# # Construir una matriz numpy de la secuencia
data = np.fromstring (stream.getvalue (), dtype = np.uint8)

# # “Decodifica” la imagen de la matriz, conservando el color
act_image = cv2.imdecode (datos, 1)

ret, act_image = cam.read ()
req_image = cv2.resize (act_image, (FRAME_WIDTH, FRAME_HEIGHT))
si cuenta% 5 == 0:
[req_image, border] = detect_human (req_image)
if border == None:
imprimir “no humano”
más:
imprimir “detectado”, i
i + 1
cv2.imwrite (‘Detected human’ + ‘. jpg’, act_image)

cv2.imshow (“Video”, req_image)
clave = cv2.waitKey (VIDEO_INTERVAL)
k = cv2.waitKey (5) y 0xFF
si k == 27:
rotura

cuenta + = 1
más:
cuenta + = 1
cv2.imshow (“Video”, req_image)
clave = cv2.waitKey (VIDEO_INTERVAL)
Hacer continuación
# compare las coordenadas de la cara del cuadro actual y el anterior
if flag == 1 and border! = Ninguno:
prev_border = [border [i] para i en xrange (len (border))]
bandera = 0
elif border! = Ninguno:
La función compare_borders (np.array (prev_border), np.array (border)) aún no se ha definido 😛
prev_border = [border [i] para i en xrange (len (border))]

principal()
cv2.destroyAllWindows ()

Para el reconocimiento facial, creamos una base de datos facial compuesta por usuarios autenticados. Recolectamos las imágenes de caras en diferentes ángulos, diferentes iluminaciones, con y sin sonrisa, ojos abiertos y cerrados, etc. Cuando el código anterior detecta a cualquier humano, recorta la imagen y extrae la cara de ella. Ahora use el algoritmo de reconocimiento facial para detectar si la cara es de persona autenticada o no. Puede usar cualquiera de los algoritmos de reconocimiento facial. Siga este sitio para obtener más información Reconocimiento facial con OpenCV.

Si la cara detectada es de una persona no autenticada, el bot envía correo al centro de retransmisión a través del protocolo SMTP.

Aquí está la foto del bot.

No dude en ponerse en contacto conmigo en [email protected]

Cámaras