class FaceDetectionProcess():
def __init__(self):
self.logger = LoggerFactory()
self.config = ConfigReader()
self.request_manager = DetectionRequestsManager()
self.directory = DirectoryManager()
self.faceDetectionRepository = FaceDetectionRepository()
self.pathsProvider = PathsProvider()
@exception
def run_face_detection(self):
self.logger.info(" START FaceDetection")
requests = self.faceDetectionRepository.get_all_not_completed()
if not requests == null:
for request in requests:
try:
self.request_manager.process_request(request)
self.faceDetectionRepository.complete_request(request.id)
except Exception as ex:
self.logger.error(
f"Exception when processing detection {request.id}.\n Error: {str(ex)}"
)
self.faceDetectionRepository.complete_with_error(
request.id)
self.directory.clean_directory(
self.pathsProvider.local_detection_image_path())
self.logger.info(" END FaceDetection")
class CameraOperator():
def __init__(self):
self.logger = LoggerFactory()
def init_camera(self):
if PI_CAMERA_USED:
print("Picamera cannot be launch on windows")
raise Exception("Picamera cannot be launch on windows")
# COnfiguration for Raspberry
# camera = PiCamera()
# camera.resolution = tuple(conf["resolution"])
# camera.framerate = conf["fps"]
# rawCapture = PiRGBArray(camera, size=tuple(conf["resolution"]))
else:
self.camera = cv2.VideoCapture(CAMERA_PORT)
time.sleep(CAMERA_WARMUP_TIME)
def release_camera(self):
self.camera.release()
cv2.destroyAllWindows()
def grab_frame(self):
grabbed, frame = self.camera.read()
if not grabbed:
self.logger.error("Camera didn't grab a frame, raising error")
raise Exception("Camera didn't grab a frame, raising error")
return frame
def show_video(self, frame):
cv2.imshow("Security Feed", frame)
class AzureLargeGroupTrainer():
def __init__(self):
self.logger = LoggerFactory()
self.largeGroupClient = AzureLargeGroupsClient()
self.nnFilesRepo = NeuralNetworkFileRepository()
self.nnTypes = NeuralNetworkTypes()
def train_large_group(self, request_id, name, people_with_image_paths):
try:
start = time.time()
self.largeGroupClient.create_large_group(request_id, name)
people_ids = set(
person_id for person_id, image_path in people_with_image_paths)
people_dictionary = {}
for person_id in people_ids:
person_in_group_id = self.largeGroupClient.create_person_in_large_group(
request_id, person_id)
people_dictionary[f'{person_id}'] = person_in_group_id
for person_id, image_path in people_with_image_paths:
group_person_id = people_dictionary[f'{person_id}']
self.largeGroupClient.add_face_to_person_in_large_group(
group_person_id, request_id, image_path)
self.largeGroupClient.train_large_group(request_id)
end = time.time()
file_size = '0'
neural_network_file_entity = NeuralNetworkFile(
str(request_id), request_id, self.nnTypes.azure_large_group_id,
str(end - start), '1>', file_size, str(people_dictionary))
# people dictionary may become problematic when group is very big
self.nnFilesRepo.add_neural_network_file(
neural_network_file_entity)
except Exception as ex:
self.logger.error(
f"Exception when creating Azure Large Group. Exception: {ex}")
class Dht11Reader:
def __init__(self):
self.logger = LoggerFactory()
gpio.setmode(gpio.BCM)
def get_readings(self):
self.logger.info(f"Reading value from dht11")
try:
self.logger.info(f"read value here")
except Exception as ex:
self.logger.error(f"Error '{ex}' when reading value from DHT11")
class Tester:
def __init__(self):
self.logger = LoggerFactory()
self.imagesProvider = PeopleImagesProvider()
self.recognizersProvider = FaceRecognizerProvider()
self.openCvRecognizer = OpenCvFaceRecognizerForTesting()
self.azureRecognizer = AzureFaceRecognizer()
self.faceDetector = FaceDetectorsManager()
self.neuralNetworkToUse = 44
def test_all_photos(self):
azure_counter = 0
fisher_counter = 0
eigen_counter = 0
lbph_counter = 0
faces = 0
all_photos_with_people = self.imagesProvider.get_image_paths_for_people(
range(2, 102), 20)
fisher, eigen, lbph = self.recognizersProvider.create_open_cv_face_recognizers_with_type(
self.neuralNetworkToUse)
self.logger.info("test")
for person_id, person_image in all_photos_with_people:
faces = faces + 1
azure_result = 0
fisher_result = 0
eigen_result = 0
lbph_result = 0
try:
azure_result = self.azureRecognizer.recognize_face_without_db(
18, person_image)
fisher_result = self.openCvRecognizer.recognize_with_single_recognizer_with_dnn(
fisher, person_image)
eigen_result = self.openCvRecognizer.recognize_with_single_recognizer_with_dnn(
eigen, person_image)
lbph_result = self.openCvRecognizer.recognize_with_single_recognizer_with_dnn(
lbph, person_image)
except Exception as exception:
self.logger.error(exception)
if person_id == int(azure_result):
azure_counter = azure_counter + 1
if person_id == fisher_result:
fisher_counter = fisher_counter + 1
if person_id == eigen_result:
eigen_counter = eigen_counter + 1
if person_id == lbph_result:
lbph_counter = lbph_counter + 1
self.logger.info(
f"FACES: {faces} Azure: {azure_counter} Fisher: {fisher_counter}"
f" Eigen: {eigen_counter} LBPH: {lbph_counter}")
class TrainingDataProvider():
def __init__(self):
self.logger = LoggerFactory()
self.faceDetector = DnnFaceDetector()
self.imageConverter = ImageConverter()
self.face_samples = []
self.ids = []
def get_training_data_for_neural_network(self, request_id: int,
people_with_image_paths):
self.logger.info(
f"Preparing training data for NeuralNetwork request : {request_id}"
)
self.face_samples.clear()
self.ids.clear()
for person_id, person_image in people_with_image_paths:
self.__extract_training_data__(person_image, person_id)
self.logger.info(f"face_samples:\n {self.face_samples}"
f"\nids: {self.ids}")
self.logger.info(
f"Preparing training data for NeuralNetwork request : {request_id} FINISHED"
)
return self.face_samples, np.array(self.ids)
def __extract_training_data__(self, image_path, person_id):
self.logger.info(image_path)
open_cv_image = cv2.imread(image_path)
faces = []
try:
faces = self.faceDetector.run_detector(open_cv_image)
except Exception as ex:
self.logger.info(
f"Exception when extracting data from {image_path}. Ex: {ex}")
if len(faces) is not 0:
self.__add_sample__(faces, open_cv_image, person_id)
def __add_sample__(self, faces, open_cv_image, person_id):
try:
(startX, startY, endX, endY) = faces[0]
cropped_image = open_cv_image[startY:endY, startX:endX]
np_image = self.imageConverter.convert_to_np_array(cropped_image)
self.face_samples.append(np_image)
self.ids.append(person_id)
except Exception as exception:
self.logger.error(
f"Exception when converting to np array.Ex {exception}")
class NeuralNetworkTrainingRunner():
def __init__(self):
self.logger = LoggerFactory()
self.peopleManager = PeopleDownloader()
self.nnManager = NeuralNetworkRequestsManager()
self.nnRepo = NeuralNetworkRepository()
@exception
def run_training(self):
self.logger.info(" START NeuralNetworkTraining")
requests = self.nnRepo.get_all_not_completed()
if not requests == null and requests.count() is not 0:
self.peopleManager.download_people_to_local()
for request in requests:
try:
self.nnManager.process_request(request)
except Exception as ex:
self.logger.error(f"Exception when processing neural network training {request.id}.\n Error: {str(ex)}")
self.nnRepo.complete_with_error(request.id)
self.logger.info(" END NeuralNetworkTraining")
class AzureLargeGroupTester:
def __init__(self):
self.logger = LoggerFactory()
self.cfClient = CognitiveClient()
def run_program(self):
self.logger.info("START CleanUp")
number = 1
while True:
try:
self.logger.info(f"Deleting large group with id {number}")
self.cfClient.delete_large_person_group(number)
number = number + 1
except Exception as ex:
number = number + 1
self.logger.error(ex)
self.logger.info("END CleanUp")
def check_name(self):
self.logger.info("START CleanUp")
res = self.cfClient.get_person_name(
4, 'f6a55407-1bb7-49f2-976d-a1fc58d52127')
self.logger.info(res)
self.logger.info("END CleanUp")
def check_status(self):
self.logger.info("START checkstatus")
res = self.cfClient.get_large_group_status(8)
self.logger.info(res)
self.logger.info("END checkstatus")
def get_azure_group(self):
self.logger.info("START checkstatus")
res = self.cfClient.get_large_group(6)
self.logger.info(res)
self.logger.info("END checkstatus")
class FaceRecognitionProcess():
def __init__(self):
self.logger = LoggerFactory()
self.config = ConfigReader()
self.faceRecognitionManager = RecognitionRequestManager()
self.faceRecognitionRepo = FaceRecognitionRepository()
self.neuralNetworksManager = NeuralNetworksProvider()
@exception
def run_face_recognition(self):
self.logger.info(" START FaceRecognition")
requests = self.faceRecognitionRepo.get_all_not_completed()
if not requests == null and requests.count() is not 0:
self.neuralNetworksManager.download_neural_networks_to_local()
for request in requests:
try:
self.faceRecognitionManager.process_request(request)
self.faceRecognitionRepo.complete_request(request.id)
except Exception as ex:
self.logger.error(
f"Exception when processing recognition {request.id}.\n Error: {str(ex)}"
)
self.faceRecognitionRepo.complete_with_error(request.id)
self.logger.info(" END FaceRecognition")
class AzureFaceClient():
def __init__(self):
self.cognitiveClient = CognitiveClient()
self.resultsConverter = ResultsConverter()
self.logger = LoggerFactory()
def get_face_rectangles(self, image_path):
self.logger.info(f"Getting face rectangles for image {image_path}")
try:
result = self.cognitiveClient.detect_faces(image_path)
faces = self.resultsConverter.get_face_rectangles_from_result(
result)
return faces
except CognitiveFaceException as exp:
self.logger.error(
f'Exception when sending face detection request. Response: {exp.code}. {exp.msg}'
)
def get_face_ids(self, path):
self.logger.info(f"Getting face ids for image {path}")
try:
result = self.cognitiveClient.detect_faces(path)
faces = self.resultsConverter.get_face_ids_from_result(result)
return faces
except CognitiveFaceException as exp:
self.logger.error(
f'Exception when sending face detection request. Response: {exp.code}. {exp.msg}'
)
def get_faces_identity(self, faces_ids, large_group_id):
self.logger.info(f"Getting faces identity for faces_ids {faces_ids}")
try:
result = self.cognitiveClient.identify_faces(
faces_ids, large_group_id)
azure_faces_identities = self.resultsConverter.get_face_identities_from_result(
result)
return azure_faces_identities
except CognitiveFaceException as exp:
self.logger.error(
f'Exception when sending identify face request. Response: {exp.code}. {exp.msg}'
)
class NeuralNetworkTypes:
def __init__(self):
self.logger = LoggerFactory()
@property
def lbph(self):
return "LBPH"
@property
def eigen(self):
return "Eigen"
@property
def fisher(self):
return "Fisher"
@property
def azure_large_group(self):
return "AzureLargeGroup"
@property
def lbph_id(self):
return 1
@property
def eigen_id(self):
return 2
@property
def fisher_id(self):
return 3
@property
def azure_large_group_id(self):
return 4
def get_type_id(self, nn_type_name: str):
if nn_type_name.lower() == self.lbph.lower():
return self.lbph_id
elif nn_type_name.lower() == self.eigen.lower():
return self.eigen_id
elif nn_type_name.lower() == self.fisher.lower():
return self.fisher_id
elif nn_type_name.lower() == self.azure_large_group.lower():
return self.azure_large_group_id
else:
raise Exception(
f"Wrong nn_type_name. Cant find a match for : {nn_type_name}")
def get_type_name(self, nn_type_id: int):
if nn_type_id is self.lbph_id:
return self.lbph
elif nn_type_id is self.fisher_id:
return self.fisher
elif nn_type_id is self.eigen_id:
return self.eigen
elif nn_type_id is self.azure_large_group_id:
return self.azure_large_group
else:
self.logger.error(f"Unknown nn_type_id: {nn_type_id}")
return "Unknown"
class AzureLargeGroupsClient():
def __init__(self):
self.cognitiveClient = CognitiveClient()
self.logger = LoggerFactory()
self.resultsConverter = ResultsConverter()
def create_large_group(self, request_id: int, name: str):
self.logger.info(
f"Creating Azure LargePersonGroup with id: {request_id}, name : {name} at {datetime.datetime.now()}"
)
try:
self.cognitiveClient.create_large_group(request_id, name)
except Exception as ex:
self.logger.error(f"Exception when creating large group. Ex: {ex}")
raise
def create_person_in_large_group(self, large_group_id, person_name):
self.logger.info(
f"Creating person: {person_name} in large group: {large_group_id}")
try:
res = self.cognitiveClient.create_person_in_large_group(
large_group_id, person_name)
person_id = res['personId']
return person_id
except Exception as ex:
self.logger.error(
f"Exception when creating person in large group. Ex: {ex}")
raise
def add_face_to_person_in_large_group(self, person_id, large_group_id,
image_path):
self.logger.info(
f"Adding image {image_path} to person {person_id} in large group {large_group_id}"
)
try:
self.cognitiveClient.add_face_to_person_in_large_group(
person_id, large_group_id, image_path)
except self.cognitiveClient.client.CognitiveFaceException as ex:
self.logger.error(
f"Exception when adding face from {image_path}.Process will continue. Ex: {ex}"
)
if not (ex.status_code == 400 and ex.code == 'InvalidImage'):
raise
except Exception as ex:
self.logger.error(
f"Exception when adding face to person in large group. ImagePath: {image_path}. Ex: {ex}"
)
raise
def train_large_group(self, large_group_id):
self.logger.info(
f"Starting training of azure large group id: {large_group_id} at: {datetime.datetime.now()}"
)
try:
self.cognitiveClient.train_large_group(large_group_id)
except Exception as ex:
self.logger.error(f"Exception when training large group. Ex: {ex}")
raise
def get_large_group_status(self, large_group_id):
self.logger.info(
f"Checking status of large group id: {large_group_id}")
try:
res = self.cognitiveClient.get_large_group_status(large_group_id)
self.logger.info(f"Azure NN status :{res}")
return res
except Exception as ex:
self.logger.error(
f"Exception when checking large group status. Ex: {ex}")
raise
def get_person_in_large_group_name(self, large_group_id,
person_specific_number):
self.logger.info(
f"Checking Name of person in large group :{large_group_id} under id :{person_specific_number}"
)
try:
res = self.cognitiveClient.get_person_name(large_group_id,
person_specific_number)
self.logger.info(f"Person name :{res['name']}")
return res['name']
except Exception as ex:
self.logger.error(
f"Exception when getting name of person in large group. Ex: {ex}"
)
raise
