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 FaceDetectorsManager(): def __init__(self): self.config = ConfigReader() self.logger = LoggerFactory() self.haarDetector = HaarFaceDetector() self.dnnDetector = DnnFaceDetector() self.azureDetectionClient = AzureFaceClient() self.detectionTypes = DetectionTypes() def get_faces_on_image_from_file_path(self, file_path): image = cv2.imread(file_path) time_before = time.time() faces_detected_by_haar = self.haarDetector.run_detector(image) time_after_haar = time.time() faces_detected_by_dnn = self.dnnDetector.run_detector(image) time_after_dnn = time.time() faces_detected_by_azure = self.azureDetectionClient.get_face_rectangles(file_path) time_after_azure = time.time() result = [[self.detectionTypes.haar, faces_detected_by_haar, time_after_haar - time_before], [self.detectionTypes.dnn, faces_detected_by_dnn, time_after_dnn - time_after_haar], [self.detectionTypes.azure, faces_detected_by_azure, time_after_azure - time_after_dnn]] self.logger.info(f"Faces detected: \n {result}") return result def get_faces_on_image(self, image): faces_detected_by_haar = self.haarDetector.run_detector(image) faces_detected_by_dnn = self.dnnDetector.run_detector(image) self.logger.info(f"Faces detected by " f"\n Haar: {faces_detected_by_haar}" f"\n DNN: {faces_detected_by_dnn}") return faces_detected_by_haar, faces_detected_by_dnn def get_face_by_haar(self, image): faces_detected_by_haar = self.haarDetector.run_detector(image) self.logger.info(f"Faces detected by " f"\n Haar: {faces_detected_by_haar}") return faces_detected_by_haar def get_face_by_dnn(self, image): faces_detected_by_dnn = self.dnnDetector.run_detector(image) self.logger.info(f"Faces detected by " f"\n DNN: {faces_detected_by_dnn}") return faces_detected_by_dnn def get_face_by_azure(self, file_path): faces_detected_by_azure = self.azureDetectionClient.get_face_rectangles(file_path) self.logger.info(f"Faces detected by " f"\n Azure: {faces_detected_by_azure}") return faces_detected_by_azure def get_face_by_haar_with_load_image(self, file_path): image = cv2.imread(file_path) return self.get_face_by_haar(image) def get_face_by_dnn_with_load_image(self, file_path): image = cv2.imread(file_path) return self.get_face_by_dnn(image)
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 NeuralNetworkRequestsManager(): def __init__(self): self.logger = LoggerFactory() self.neuralNetworkRepo = NeuralNetworkRepository() self.neuralNetworksTrainingManager = NeuralNetworksTrainingManager() def process_request(self, request: NeuralNetwork): self.logger.info(f"Working on creating neural network for request with {request.id} id") self.neuralNetworksTrainingManager.create_all_neural_networks(request.id, request.name, request.maxNumberOfPhotosPerPerson) self.neuralNetworkRepo.complete_request(request.id)
class ProgramRunner: def __init__(self): self.logger = LoggerFactory() self.detectionProcessRunner = FaceDetectionProcess() self.recognitionProcessRunner = FaceRecognitionProcess() self.neuralNetworkTrainingProcessRunner = NeuralNetworkTrainingRunner() def run_program(self): self.logger.info("START APP") self.detectionProcessRunner.run_face_detection() self.neuralNetworkTrainingProcessRunner.run_training() self.recognitionProcessRunner.run_face_recognition() self.logger.info("END APP")
class RecognitionRequestManager(): def __init__(self): self.logger = LoggerFactory() self.inputFileProvider = InputFileProvider() self.recognitionRepository = FaceRecognitionRepository() self.recognizersManager = FaceRecognizersManager() def process_request(self, request: Recognition): self.logger.info(f"Working on face recognition request {request.id} id") input_file_path = self.inputFileProvider.get_recognition_input_file_path(request.id) self.recognizersManager.get_identity_by_open_cv_recognizers(request.id, request.neural_network_id, input_file_path) self.recognizersManager.get_identity_by_azure_cognitive(request.id, request.neural_network_id, input_file_path) self.logger.info(f"Completed recognition request id: {request.id} name: {request.name}")
class ResultsOperator: def __init__(self): self.imageEditor = ImageEditor() self.filesUploader = FilesUploader() self.files_repository = ImageAttachmentRepository() self.pathsProvider = PathsProvider() self.attachmentTypes = ImageAttachmentTypes() self.detectionTypes = DetectionTypes() self.resultsRepository = DetectionResultRepository() self.logger = LoggerFactory() @exception def prepare_and_upload_results(self, request_id: int, results, image_file_path): for res in results: type_name = res[0] file_name = f"{type_name}.jpg" faces = res[1] processing_time = res[2] if faces is None: return self.logger.info(f"Working on results for {type_name} \n{faces}") result_file_path = os.path.join( self.pathsProvider.local_detection_image_path(), str(request_id), file_name) self.__save_result_image_to_local_directory__( faces, image_file_path, result_file_path) result_entity = self.__prepare_result_entities__( faces, file_name, request_id, type_name, processing_time) result_id = self.resultsRepository.add_detection_result_with_image( result_entity) result_file = open(result_file_path, "rb") self.filesUploader.upload_detection_result(result_id, result_file.read(), file_name) def __prepare_result_entities__(self, faces, file_name, request_id, type_name, proc_time): image_attachment = ImageAttachment( file_name, self.attachmentTypes.detection_result_id) faces_coordinates = [DetectionRectangle(faces) for faces in faces] result_entity = DetectionResult( request_id, self.detectionTypes.get_type_id(type_name), image_attachment, faces_coordinates, str(proc_time)) return result_entity def __save_result_image_to_local_directory__(self, faces, image_file_path, result_file_path): image = cv2.imread(image_file_path) result_image_data = self.imageEditor.draw_faces(image, faces) cv2.imwrite(result_file_path, result_image_data)
class NeuralNetworkResultsSaver(): def __init__(self): self.logger = LoggerFactory() self.pathsProvider = PathsProvider() self.filesUploader = FilesUploader() self.nnFilesRepo = NeuralNetworkFileRepository() self.nnTypes = NeuralNetworkTypes() self.stringOperator = StringOperator() def save_result_files(self, neural_network_id, training_times, data_preparation_time): base_path = path.join(self.pathsProvider.local_neural_network_path(), str(neural_network_id)) file_paths = [path.join(base_path, f) for f in listdir(base_path)] for file_path in file_paths: file_name, nn_type_id = self.__get_file_name_and_file_type_id( file_path) training_time_of_nn = training_times[nn_type_id] self.__save_data__(file_name, neural_network_id, nn_type_id, file_path, training_time_of_nn + data_preparation_time, training_time_of_nn) # commented because files are now too big # self.__upload_result_file__(file_name, file_path, neural_network_id) def __save_data__(self, file_name, neural_network_id, nn_type_id, file_path, process_time, training_time): file_size = get_file_size(file_path) neural_network_file_entity = NeuralNetworkFile(file_name, neural_network_id, nn_type_id, str(process_time), str(training_time), file_size) self.nnFilesRepo.add_neural_network_file(neural_network_file_entity) self.logger.info(f"Upload of file {file_name} FINISHED") def __upload_result_file__(self, file_name, file_path, neural_network_id): self.logger.info( f"Upload of file {file_name} STARTED (possible timeout error on weak network and big file size)" ) opened_file = open(file_path, 'rb') self.filesUploader.upload_neural_network(neural_network_id, opened_file.read(), file_name) def __get_file_name_and_file_type_id(self, file_path): file_name = self.stringOperator.get_file_name_from_path(file_path) nn_type_name = self.stringOperator.find_between(file_name, '_', '.') nn_type_id = self.nnTypes.get_type_id(nn_type_name) return file_name, nn_type_id
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 FilesDownloader(): def __init__(self): self.pathsProvider = PathsProvider() self.dropbox = DropboxClient() self.directory = DirectoryManager() self.logger = LoggerFactory() def download_detection_input(self, request_id: int): dropbox_request_path = os.path.join( self.pathsProvider.dropbox_detection_image_path(), str(request_id)).replace("\\", "/") local_save_path = os.path.join( self.pathsProvider.local_detection_image_path(), str(request_id)) self.__single_file_download__(dropbox_request_path, local_save_path) self.logger.info( F"Finished downloading input for detection with id :{request_id}") def download_person(self, person_id: int): dropbox_person_path = os.path.join( self.pathsProvider.dropbox_person_image_path(), str(person_id)).replace("\\", "/") local_save_path = os.path.join( self.pathsProvider.local_person_image_path(), str(person_id)) self.__multiple_file_download__(dropbox_person_path, local_save_path) self.logger.info(F"Finished downloading person with id :{person_id}") def download_recognition_input(self, request_id: int): dropbox_request_path = os.path.join( self.pathsProvider.dropbox_recognition_image_path(), str(request_id)).replace("\\", "/") local_save_path = os.path.join( self.pathsProvider.local_recognition_image_path(), str(request_id)) self.__single_file_download__(dropbox_request_path, local_save_path) self.logger.info( F"Finished downloading input for recognition with id :{request_id}" ) def download_neural_network(self, nn_id: int): dropbox_neural_network_path = os.path.join( self.pathsProvider.dropbox_neural_network_path(), str(nn_id)).replace("\\", "/") local_save_path = os.path.join( self.pathsProvider.local_neural_network_path(), str(nn_id)) self.__multiple_file_download__(dropbox_neural_network_path, local_save_path) self.logger.info( F"Finished downloading neural network with id :{nn_id}") def __single_file_download__(self, dropbox_request_path, local_save_path): self.directory.create_directory_if_doesnt_exist(local_save_path) self.dropbox.download_single_file(dropbox_request_path, local_save_path) def __multiple_file_download__(self, dropbox_folder_path, local_save_path): self.directory.clean_directory(local_save_path) self.directory.create_directory_if_doesnt_exist(local_save_path) self.dropbox.download_folder(dropbox_folder_path, local_save_path)
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 MovementResultOperator: def __init__(self): self.imageEditor = ImageEditor() self.pathsProvider = PathsProvider() self.attachmentTypes = ImageAttachmentTypes() self.filesUploader = FilesUploader() self.movementRepo = MovementRepository() self.directoryManager = DirectoryManager() self.logger = LoggerFactory() def prepare_and_upload_result(self, frame, movements): self.logger.info("Movement detected") file_name = f"motion_{datetime.now().date()}.png" new_id = self.__add_movement_to_db__(file_name) file_path_to_create = os.path.join( self.pathsProvider.local_motion_image_path(), str(new_id)) file_path = os.path.join(file_path_to_create, file_name) self.directoryManager.create_directory_if_doesnt_exist( file_path_to_create) self.__save_result_image_to_local_directory__(frame, movements, file_path) self.__upload_movement_photo__(file_name, file_path, new_id) def __upload_movement_photo__(self, file_name, file_path, new_id): self.logger.info(f"Uploading file :{file_path}") result_file = open(file_path, "rb") self.filesUploader.upload_detected_motion(new_id, result_file.read(), file_name) def __add_movement_to_db__(self, file_name): image_attachment = ImageAttachment(file_name, self.attachmentTypes.movement_id) notification_entity = Movement("Movement detected", image_attachment) motion_id = self.movementRepo.add_movement(notification_entity) return motion_id def __save_result_image_to_local_directory__(self, frame_to_upload, detected_movemenets, file_name): if MOVEMENT_TIMESTAMP: self.imageEditor.mark_frame(frame_to_upload, 'Occupied') if MOVEMENT_MARKING: self.imageEditor.draw_contour(detected_movemenets, frame_to_upload) cv2.imwrite(file_name, frame_to_upload)
class PeopleDownloader(): def __init__(self): self.logger = LoggerFactory() self.pathProvider = PathsProvider() self.directoryManager = DirectoryManager() self.peopleRepo = PersonRepository() self.filesDownloader = FilesDownloader() def download_people_to_local(self): people_path = self.pathProvider.local_person_image_path() directories = self.directoryManager.get_subdirectories_with_files_count( people_path) people = self.peopleRepo.get_people_ids_with_images_count() people_to_download = [x for x in people if x not in directories] self.logger.info(f"directories {directories} " f"\npeople: {people}" f"\npeople_to_download: {people_to_download}") for p in people_to_download: self.filesDownloader.download_person((p[0]))
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 NeuralNetworksProvider(): def __init__(self): self.pathProvider = PathsProvider() self.logger = LoggerFactory() self.filesDownloader = FilesDownloader() self.nnRepo = NeuralNetworkRepository() self.directoryManager = DirectoryManager() def download_neural_networks_to_local(self): nn_path = self.pathProvider.local_neural_network_path() directories = self.directoryManager.get_subdirectories_with_files_count( nn_path) neural_networks = self.nnRepo.get_completed_neural_networks_ids_with_downloadable_files_count( ) nns_to_download = [x for x in neural_networks if x not in directories] self.logger.info(f"directories {directories} " f"\nneural_networks: {neural_networks}" f"\nneural_networks_to_download: {nns_to_download}") for nn in nns_to_download: self.filesDownloader.download_neural_network(nn[0])
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 = 40 def test_all_photos(self): faces = 0 all_photos_with_people = self.imagesProvider.get_image_paths_for_people(range(2, 102), 20) self.logger.info("test") for person_id, person_image in all_photos_with_people: found_faces= self.faceDetector.get_face_by_azure(person_image) if found_faces == 0 or len(found_faces) == 0: continue else: faces = faces + 1 self.logger.info(f"FACES: {faces} ")
class OpenCvFaceRecognizerForTesting(): def __init__(self): self.logger = LoggerFactory() self.faceDetectorManager = FaceDetectorsManager() self.imageConverter = ImageConverter() def recognize_with_single_recognizer_with_haar(self, face_recognizer, image_path): detection_start = time.time() image = cv2.imread(image_path) detected_faces = self.faceDetectorManager.get_face_by_haar(image) detection_end = time.time() detection_time = detection_end - detection_start start_time = time.time() self.logger.info(f"Using {face_recognizer} recognizer on {image_path}") if len(detected_faces) is 0: return 0 (startX, startY, endX, endY) = detected_faces[0] predict_image = self.imageConverter.convert_to_np_array( image[startY:endY, startX:endX]) nbr_predicted, confidence = face_recognizer.predict(predict_image) return nbr_predicted def recognize_with_single_recognizer_with_dnn(self, face_recognizer, image_path): detection_start = time.time() image = cv2.imread(image_path) detected_faces = self.faceDetectorManager.get_face_by_dnn(image) detection_end = time.time() detection_time = detection_end - detection_start start_time = time.time() self.logger.info(f"Using {face_recognizer} recognizer on {image_path}") if len(detected_faces) is 0: return 0 (startX, startY, endX, endY) = detected_faces[0] predict_image = self.imageConverter.convert_to_np_array( image[startY:endY, startX:endX]) nbr_predicted, confidence = face_recognizer.predict(predict_image) return nbr_predicted
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 DetectionRequestsManager(): def __init__(self): self.logger = LoggerFactory() self.faceDetectorsManager = FaceDetectorsManager() self.resultsOperator = ResultsOperator() self.inputFileProvider = InputFileProvider() def process_request(self, request: Detection): self.logger.info( f"Working on Face Detection Request id: {request.id} started") input_file_path = self.inputFileProvider.get_detection_input_file_path( request.id) self.logger.info(f"Running all face detectors") results = self.faceDetectorsManager.get_faces_on_image_from_file_path( input_file_path) self.resultsOperator.prepare_and_upload_results( request.id, results, input_file_path) self.logger.info(f"Finished Face Detection Request id: {request.id} ")
class SensorsOperator(): def __init__(self): self.logger = LoggerFactory() self.readingsRepo = SensorsReadingRepository() self.dht11Reader = Dht11ReaderCheater() self.notifications = NotificationsService() self.settingsTypes = NotificationSettingsTypes() def add_readings(self): self.logger.info(f"Starting retriving readings") temp, hum = self.dht11Reader.read_values() self.logger.info(f"Temp: {temp}\n Hum: {hum}") self.readingsRepo.add_reading(temp, hum) readings_dictionary = { self.settingsTypes.temperature: temp, self.settingsTypes.humidity: hum } self.notifications.add_reading_notification_if_required( readings_dictionary) self.logger.info(f"Sensors readings finished")
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 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
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 OpenCvFaceRecognizer(): def __init__(self): self.logger = LoggerFactory() self.faceDetectorManager = FaceDetectorsManager() self.imageConverter = ImageConverter() self.recognitionResultRepo = RecognitionResultRepository() def recognize_face_from_image(self, request_id, recognizers, image_path): detection_start = time.time() image = cv2.imread(image_path) detected_faces = self.faceDetectorManager.get_face_by_dnn(image) detection_end = time.time() detection_time = detection_end - detection_start for face_recognizer, file_id in recognizers: start_time = time.time() self.logger.info( f"Using {face_recognizer} recognizer created from {file_id} file id" ) if len(detected_faces) is 0: self.__add_empty_result__(file_id, request_id, start_time, detection_time) for (startX, startY, endX, endY) in detected_faces: predict_image = self.imageConverter.convert_to_np_array( image[startY:endY, startX:endX]) nbr_predicted, confidence = face_recognizer.predict( predict_image) self.__add_result__(confidence, file_id, nbr_predicted, request_id, start_time, detection_time) def recognize_with_single_recognizer(self, face_recognizer, image_path): detection_start = time.time() image = cv2.imread(image_path) detected_faces = self.faceDetectorManager.get_face_by_haar(image) detection_end = time.time() detection_time = detection_end - detection_start start_time = time.time() self.logger.info(f"Using {face_recognizer} recognizer on {image_path}") if len(detected_faces) is 0: return 0 (startX, startY, endX, endY) = detected_faces[0] predict_image = self.imageConverter.convert_to_np_array( image[startY:endY, startX:endX]) nbr_predicted, confidence = face_recognizer.predict(predict_image) return nbr_predicted def __add_result__(self, confidence, file_id, nbr_predicted, request_id, start_time, detection_time): self.logger.info( f"Recognized identity: {nbr_predicted} confidence:{confidence}") end_time = time.time() process_time = end_time - start_time + detection_time result = RecognitionResult(nbr_predicted, request_id, confidence, file_id, str(process_time)) self.recognitionResultRepo.add_recognition_result(result) def __add_empty_result__(self, azure_file, request_id, start_time, detection_time): end_time = time.time() process_time = end_time - start_time + detection_time result = RecognitionResult(0, request_id, 0, azure_file.id, str(process_time), "No faces detected") self.recognitionResultRepo.add_recognition_result(result)