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()
