def __init__(self):
# Using OpenCV to capture from device 0. If you have trouble capturing
# from a webcam, comment the line below out and use a video file
# instead.
self.video = cv2.VideoCapture(0)
# If you decide to use video.mp4, you must have this file in the folder
# as the main.py.
# self.video = cv2.VideoCapture('video.mp4')
self.userManager = UserManager()
self.last_frame = None
self._classificador = cv2.CascadeClassifier('frontalface.xml')
self._altura = 220
self._largura = 220
self._font = cv2.FONT_HERSHEY_COMPLEX_SMALL
self._lbphClassifier = cv2.face.LBPHFaceRecognizer_create()
self._lbphClassifier.read(
'../FaceRecognizer/Dependencies/classifierLbph.yml')
def __init__(self):
"""Instanciar o objeto do tipo CameraRecognizer.
Ao fazer isso, preenchem-se os seguintes campos:
self._userManager = Controle do usuário – FaceRecognizer.Services.UserManager;
self._height = Altura – valor numérico;
self._width = Largura – valor numérico;
self._font = tipo de fonte usado no preenchimento do nome e do identificador do usuário reconhecido;
self._lbphClassifier = classificador de face que utiliza o algoritmo de reconhecimento facial LBPH. Só será preenchido se o arquivo .yml existir.
"""
self.userManager=UserManager()
self._classifier= cv2.CascadeClassifier('FaceRecognizer/Dependencies/frontalface.xml')
self._height = 220
self._width = 220
self._font = cv2.FONT_HERSHEY_COMPLEX_SMALL
self._lbphClassifier = cv2.face.LBPHFaceRecognizer_create()
try:
self._lbphClassifier.read('FaceRecognizer/Dependencies/classifierLbph.yml')
except:
print('No YML')
self._lbphClassifier=None
from flask import jsonify, request, json
from app.user import app_user
from app.recognition.resource import Recognition_Resource
from app.user.resource import User_Resource
from FaceRecognizer.Services.UserManager import UserManager
from FaceRecognizer.Services.FileManager import FileManager
import cv2
import base64
userManager = UserManager()
fileManager = FileManager()
image_faces = []
userResource = User_Resource()
@app_user.route('/add_image', methods=['POST'])
def add_image():
image_faces.append(Recognition_Resource.last_frame)
ret, jsonImage = cv2.imencode('.jpg', Recognition_Resource.last_frame)
jpg_as_text = base64.b64encode(jsonImage.tobytes())
jpg_as_text = jpg_as_text.decode('ascii')
return jsonify({
'message': 'Success',
'image_face': json.dumps(jpg_as_text)
})
@app_user.route('/clear_image_faces')
def clear_image_faces():
image_faces.clear()
return jsonify({'message': 'Success'})
class VideoCamera(object):
def __init__(self):
# Using OpenCV to capture from device 0. If you have trouble capturing
# from a webcam, comment the line below out and use a video file
# instead.
self.video = cv2.VideoCapture(0)
# If you decide to use video.mp4, you must have this file in the folder
# as the main.py.
# self.video = cv2.VideoCapture('video.mp4')
self.userManager = UserManager()
self.last_frame = None
self._classificador = cv2.CascadeClassifier('frontalface.xml')
self._altura = 220
self._largura = 220
self._font = cv2.FONT_HERSHEY_COMPLEX_SMALL
self._lbphClassifier = cv2.face.LBPHFaceRecognizer_create()
self._lbphClassifier.read(
'../FaceRecognizer/Dependencies/classifierLbph.yml')
def __del__(self):
self.video.release()
# def get_frame(self):
#
# imagem, frame = self.video.read()
#
# imagem_cinza = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#
# faces_classificadas = self._classificador.detectMultiScale(imagem_cinza)
#
# for x, y, l, a in faces_classificadas:
# cv2.rectangle(frame, (x, y), (x + l, y + a), (0, 0, 255), 2)
# self.last_frame = imagem_cinza[y:(y + a), x:(x + l)]
# ret, jpeg = cv2.imencode('.jpg', frame)
#
# return jpeg.tobytes()
def recognition(self):
imagem, frame = self.video.read()
imagem_cinza = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces_classificadas = self._classificador.detectMultiScale(
imagem_cinza)
for x, y, l, a in faces_classificadas:
imagem_face = cv2.resize(imagem_cinza[y:(y + a), x:(x + l)],
(self._largura, self._altura))
cv2.rectangle(frame, (x, y), (x + l, y + a), (0, 0, 255), 2)
id, confianca = self._lbphClassifier.predict(imagem_face)
if (id > 0):
user = self.userManager.get_user_by_id(id)
cv2.rectangle(frame, (x, y), (x + l, y + a), (0, 255, 0), 2)
cv2.putText(frame, str(id), (x, y + (a + 30)), self._font, 2,
(0, 255, 0))
cv2.putText(frame, user.get_name(), (x, y + (a + 50)),
self._font, 2, (0, 255, 0))
ret, jpeg = cv2.imencode('.jpg', frame)
return jpeg.tobytes()
class CameraRecognizer(object):
def __init__(self):
"""Instanciar o objeto do tipo CameraRecognizer.
Ao fazer isso, preenchem-se os seguintes campos:
self._userManager = Controle do usuário – FaceRecognizer.Services.UserManager;
self._height = Altura – valor numérico;
self._width = Largura – valor numérico;
self._font = tipo de fonte usado no preenchimento do nome e do identificador do usuário reconhecido;
self._lbphClassifier = classificador de face que utiliza o algoritmo de reconhecimento facial LBPH. Só será preenchido se o arquivo .yml existir.
"""
self.userManager=UserManager()
self._classifier= cv2.CascadeClassifier('FaceRecognizer/Dependencies/frontalface.xml')
self._height = 220
self._width = 220
self._font = cv2.FONT_HERSHEY_COMPLEX_SMALL
self._lbphClassifier = cv2.face.LBPHFaceRecognizer_create()
try:
self._lbphClassifier.read('FaceRecognizer/Dependencies/classifierLbph.yml')
except:
print('No YML')
self._lbphClassifier=None
def recognition(self, cameraService, scaleFactor=1.1, minNeighbors=9, minSize=(140, 140)):
"""Identificar os usuários através de sua face.
Parâmetros = cameraService: instância responsável por configurar a câmera empregada – FaceRecognizer.Services.CameraService;
scaleFactor: valor equivalente ao raio ao redor do pixel central – Float – Default: 1.1;
minNeighbors: quantidade mínima de vizinhos a serem verificados – Inteiro – Default: 9;
minSize: valores referentes aos números de célucas na horizontal e vertical, respectivamente – Default: (140, 140).
Retorno = imagem reconhecida pelo OpenCv convertida em bytes, caso haja sucesso na excução do método. Se houver erro, nada será retornado."""
try:
cameraService.read()
faces_classificadas = self._classifier.detectMultiScale(cameraService.gray_image, scaleFactor=scaleFactor, minNeighbors=minNeighbors, minSize=minSize)
for x, y, l, a in faces_classificadas:
imagem_face = cv2.resize(cameraService.gray_image[y:(y + a), x:(x + l)], (self._width, self._height))
cv2.rectangle(cameraService.frame, (x, y), (x + l, y + a), (0, 0, 255), 2)
id, confianca = self._lbphClassifier.predict(imagem_face)
if (id > 0):
user = self.userManager.get_user_by_id(id)
cv2.rectangle(cameraService.frame, (x, y), (x + l, y + a), (0, 255, 0), 2)
cv2.putText(cameraService.frame, str(id), (x, y + (a + 30)), self._font, 2, (0, 255, 0))
cv2.putText(cameraService.frame, user.get_name(), (x, y + (a + 50)), self._font, 2, (0, 255, 0))
ret, jpeg = cv2.imencode('.jpg', cameraService.frame)
return jpeg.tobytes()
except:
cameraService.stop_cam()
print('Erro ao carregar o reconhecimento facial')
return
def get_lbph_classifier(self):
"""retorna o classificador lbph"""
return self._lbphClassifier
class VideoRecognizer(object):
"""Variáveis=
_lbphClassifier: classificador do algoritmo LBPH responsável por reconhecer faces atravésdo arquivo YML salvo como: Depencencies/classifierLbph.yml – Default: None;
_ids: lista com os identificadores dos usuários reconhecidos – Inteiro;
_threshold_limit: Valor que garante a credibilidade do reconhecimento facial. Se a face for superior ao número dessa variável, o reconhecimento não será validado – Inteiro – Default: 110;
_id_final: Identificador mais confiável ao término do processo de reconhecimento facial – Inteiro – Default: 0;
_userManager: Controle do usuário – FaceRecognizer.Services.UserManager."""
_lbphClassifier = None
_ids = None
_threshold_limit = 110
_id_final = 0
_userManager = UserManager()
def __init__(self, threshold=110):
"""Instancia o objeto do tipo VideoRecognizer.
Parâmetro= threshold: valor passado para ser comparado com o _threshold_limit – Inteiro – Default: 110.
Ao fazer isso, preenchem-se os campos:
_lbphClassifier: configura a variável para trabalhar com o algoritmo de reconhecimento facial LPBH;
_set_threshold_limit: configura o valor do _threshold_limit;
"""
try:
self._lbphClassifier = cv2.face.LBPHFaceRecognizer_create()
self._set_threshold_limit(threshold)
except:
print('error value')
def recognizer(self, video, max_faces=50, min_faces=5, duration=None):
"""Método empregado para reconhecer as faces detectadas no vídeo.
Parâmetros= video: endereço do arquivo de vídeo;
max_faces: quantidade máxima de faces reconhecidas – Inteiro – Default: 50;
min_faces: quantidade mínima de faces reconhecidas – Inteiro – Default: 5;
duration: duração do vídeo – Float – Default: None.
Retorno= Caso haja algum erro no processo de reconhecimento facial ou no de detecção de faces, o método apenas terá a sua execução interrompida;
Caso o reconhecimento facial seja executado com sucesso, o método look_for_user será acionado."""
try:
self._faceDetection = FaceDetector(max_faces, min_faces, duration)
image_faces = self._faceDetection.detect_video(video)
if (image_faces == False):
return
return self.look_for_user(image_faces)
except:
print('Error to recognize user')
return
def look_for_user(self, image_faces):
"""Método responsável por identificar o usuário presente nas faces – image_faces.
Parâmetro= image_faces: lista com as faces detectadas.
Retorno= Em caso de existência do arquivo classifierLbpt.yml e do consequente reconhecimento do usuário, o retorno será o identificador da pessoa classificada;
Caso não haja o arquivo classifierLbpt.yml, será exibia a mensagem 'Yml not found' e a execução do método será interrompida;
Se houver o arquivo classifierLbpt.yml, mas o usuário não for reconhecido, o retorno será None."""
try:
self._lbphClassifier.read(
'FaceRecognizer/Dependencies/classifierLbph.yml')
self._identify_user(image_faces)
return self._id_final
except:
print('Yml not found')
return
def _identify_user(self, image_faces):
"""Realiza a identificação do usuário.
Parâmetro= image_faces: lista com as faces detectadas."""
self._process_face(image_faces)
self._get_id_final()
def _get_id_final(self):
"""Retorna o identificador pertencente ao usuário identificado com maior credibilidade.
Retorno= Em caso de não identificação do usuário, o retorno será None.
Caso haja o usuário seja reconhecido, será retornado o valor do identificador."""
if (self._id_final > 0):
print(self._id_final)
return self._id_final
print('user not found')
self._id_final = None
def _process_face(self, image_faces):
"""Verifica se as faces passadas por parâmetro estão registradas no sistema.
Parâmetro= image_faces: lista com as faces detectadas."""
for face in image_faces:
id, confianca = self._lbphClassifier.predict(face)
print(confianca)
self._validate_min_confianca_and_id_final(id, confianca)
def _validate_min_confianca_and_id_final(self, id, confidence):
"""Verifica se o usuário foi identificado e preenche os valores de _threshold_limit e _id_final.
Parâmetros= id: identificador do usuário reconhecido – Inteiro;
confidence: valor que garante a credibilidade do reconhecimento."""
if (id > 0):
if (self._threshold_limit > confidence):
self._set_threshold_limit(confidence)
self._set_id_final(id)
print(id)
def _set_id_final(self, id):
"""Preenche o valor de _id_final.
Parâmetro= id: identificador do usuário reconhecido – Inteiro."""
if id and isinstance(id, int):
self._id_final = id
def _set_threshold_limit(self, threshold):
"""Preenche o valor de _threshold_limit.
Parâmetro= threshold: valor que garante a credibilidade do reconhecimento."""
if id and isinstance(id, float):
self._threshold_limit = threshold