def __init__(self): self.logger = LoggerFactory() self.pathsProvider = PathsProvider() self.filesUploader = FilesUploader() self.nnFilesRepo = NeuralNetworkFileRepository() self.nnTypes = NeuralNetworkTypes() self.stringOperator = StringOperator()
def __init__(self): self.logger = LoggerFactory() self.config = ConfigReader() self.request_manager = DetectionRequestsManager() self.directory = DirectoryManager() self.faceDetectionRepository = FaceDetectionRepository() self.pathsProvider = PathsProvider()
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 __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()
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 FilesUploader(): def __init__(self): self.pathsProvider = PathsProvider() self.dropbox = DropboxClient() def upload_detection_result(self, request_id: int, file, file_name): dropbox_save_location = os.path.join(self.pathsProvider.dropbox_detection_result_image_path(), str(request_id), file_name).replace("\\","/") self.dropbox.upload_file(dropbox_save_location, file) def upload_neural_network(self, request_id: int, file, file_name): dropbox_save_location = os.path.join(self.pathsProvider.dropbox_neural_network_path(), str(request_id), file_name).replace("\\","/") self.dropbox.upload_file(dropbox_save_location, file) def upload_detected_motion(self, request_id: int, file, file_name): dropbox_save_location = os.path.join(self.pathsProvider.dropbox_motion_image_path(), str(request_id), file_name).replace("\\", "/") self.dropbox.upload_file(dropbox_save_location, file)
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 InputFileProvider(): def __init__(self): self.filesDownloader = FilesDownloader() self.pathsProvider = PathsProvider() self.directoryManager = DirectoryManager() def get_recognition_input_file_path(self, request_id): self.filesDownloader.download_recognition_input(request_id) request_path = os.path.join(self.pathsProvider.local_recognition_image_path(), str(request_id)) input_file_path = self.directoryManager.get_file_from_directory(request_path) return input_file_path def get_detection_input_file_path(self, request_id): self.filesDownloader.download_detection_input(request_id) request_path = os.path.join(self.pathsProvider.local_detection_image_path(), str(request_id)) input_file_path = self.directoryManager.get_file_from_directory(request_path) return input_file_path
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 FaceRecognizerProvider(): def __init__(self): self.pathsProvider = PathsProvider() self.neuralNetworkProvider = NeuralNetworkProvider() self.neuralNetworkFilesRepo = NeuralNetworkFileRepository() def create_open_cv_face_recognizers_for_request(self, request_id): nn_files = self.neuralNetworkFilesRepo.get_all_open_cv_files_connected_to_neural_network( request_id) face_recognizers = [] for file in nn_files: nn_path = os.path.join( self.pathsProvider.local_neural_network_path(), str(file.neuralNetworkId), file.name) recognizer = self.neuralNetworkProvider.create_neural_network_by_type_id( nn_path, file.neuralNetworkTypeId) face_recognizers.append([recognizer, file.id]) return face_recognizers def create_open_cv_face_recognizers_with_type(self, request_id): nn_files = self.neuralNetworkFilesRepo.get_all_open_cv_files_connected_to_neural_network( request_id) eigen = [] fisher = [] lbph = [] for file in nn_files: nn_path = os.path.join( self.pathsProvider.local_neural_network_path(), str(file.neuralNetworkId), file.name) recognizer = self.neuralNetworkProvider.create_neural_network_by_type_id( nn_path, file.neuralNetworkTypeId) if file.neuralNetworkTypeId is NeuralNetworkTypes().fisher_id: fisher = recognizer elif file.neuralNetworkTypeId is NeuralNetworkTypes().eigen_id: eigen = recognizer elif file.neuralNetworkTypeId is NeuralNetworkTypes().lbph_id: lbph = recognizer return fisher, eigen, lbph
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 PeopleImagesProvider(): def __init__(self): self.pathsProvider = PathsProvider() self.logger = LoggerFactory() def get_image_paths_for_people(self, people_ids, max_photos_per_person): result = [] for person_id in people_ids: person_path = os.path.join( self.pathsProvider.local_person_image_path(), str(person_id)) image_paths = [ os.path.join(person_path, f) for f in os.listdir(person_path) ] for i, imagePath in zip(range(0, max_photos_per_person), image_paths): result.append([person_id, imagePath]) return result
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 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])
def __init__(self): self.pathsProvider = PathsProvider() self.logger = LoggerFactory()
def __init__(self): self.pathsProvider = PathsProvider() self.dropbox = DropboxClient() self.directory = DirectoryManager() self.logger = LoggerFactory()
def __init__(self): self.pathProvider = PathsProvider() self.logger = LoggerFactory() self.filesDownloader = FilesDownloader() self.nnRepo = NeuralNetworkRepository() self.directoryManager = DirectoryManager()
def __init__(self): self.pathProvider = PathsProvider()
def __init__(self): self.pathsProvider = PathsProvider() self.dropbox = DropboxClient()
def __init__(self): self.logger = LoggerFactory() self.pathProvider = PathsProvider() self.directoryManager = DirectoryManager() self.peopleRepo = PersonRepository() self.filesDownloader = FilesDownloader()
def __init__(self): self.pathsProvider = PathsProvider() self.neuralNetworkProvider = NeuralNetworkProvider() self.neuralNetworkFilesRepo = NeuralNetworkFileRepository()
def __init__(self): self.filesDownloader = FilesDownloader() self.pathsProvider = PathsProvider() self.directoryManager = DirectoryManager()