def __init__(self): """Initializes the GUI and connects its widgets to the corresponding functions.""" super(self.__class__, self).__init__() Logger.info("Creating dataset creation GUI") self.setupUi(self) self.__set_logo_icon() self.last_folder_opened = None self.frames = [] self.last_frame_image = None self.current_frame_id = 0 self.current_module_id_in_frame = 0 self.current_frame_modules = [] self.discarded_modules = {} self.accepted_modules = {} self.misdetected_modules = {} self.module_counter = { "automatic": { "accepted": 0, "discarded": 0, "misdetected": 0 }, "manual": { "accepted": 0, "discarded": 0, "misdetected": 0 } } self.thermo_thread = None self.__connect_widgets()
def __init__(self): """Initializes the ThermoThread for dataset creation. """ super(self.__class__, self).__init__() Logger.info("Created dataset creation ThermoThread") self.camera_param_file_name = None self.__load_default_paths() self.app = tg.App(input_video_path=None, camera_param_file=self.camera_param_file_name) self.processing_frame = None self.processing_frame_id = None
def __init__(self): """Initializes the GUI and connects its widgets to the corresponding functions.""" super(self.__class__, self).__init__() Logger.info("Creating themoGUI") self.setupUi(self) self.__set_logo_icon() self.thermo_thread = ThermoGuiThread() self.is_stoppable = True self.last_folder_opened = None self.__connect_widgets() self.__connect_thermo_thread() self.capture = None self.webcam_port = None
def __init__(self): """Initializes the Thermo Thread. """ super(ThermoGuiThread, self).__init__() Logger.info("Created ThermoGUI thread") self.camera_param_file_name = None self.input_file_name = None self.pause_time = 50 self.is_paused = False self.webcam_port = None self.cap = None self.should_use_webcam = False self.__load_default_paths() self.app = tg.App(input_video_path=self.input_file_name, camera_param_file=self.camera_param_file_name)
def __init__(self, checkpoint_dir: str, model_class: type, image_shape: np.ndarray, num_classes: int): """Initializes the inference object by loading the weights of an already trained model. :param checkpoint_dir: Directory of the checkpoint where the weights of the model are stored. :param model_class: Class associated to the stored weights. This class is used to build the :attr:`tf.graph` which will be used for the inference. :param image_shape: Shape of the images fed to the classifier. The images passed to the :func:`self.classify <thermography.classification.inference.Inference.classify>` function are resized according to this parameter. :param num_classes: Number of classes predicted by the model. .. warning:: The parameters must all be consistent with the preexisting weights! """ self.checkpoint_dir = checkpoint_dir self.image_shape = image_shape self.num_classes = num_classes self.graph = tf.Graph() with self.graph.as_default(): self.x = tf.placeholder(tf.float32, [None, *self.image_shape], name="input_image") self.keep_probability = tf.placeholder(tf.float32, name="keep_probability") self.model = model_class(x=self.x, image_shape=self.image_shape, num_classes=self.num_classes, keep_prob=self.keep_probability) self.logits = self.model.logits self.probabilities = tf.nn.softmax(self.logits) # Add ops to save and restore all the variables. self.sess = tf.Session(graph=self.graph) # Restore variables from disk. with self.sess.as_default(): with self.graph.as_default(): self.saver = tf.train.Saver() self.saver.restore( self.sess, os.path.join(self.checkpoint_dir, self.model.name)) Logger.info("Model restored.")
def setup_logger(console_log_level: LogLevel = LogLevel.INFO, file_log_level: LogLevel = LogLevel.DEBUG, log_file_name: str = None): """Sets up the simple logger. :param console_log_level: Log level associated to the streaming log. :param file_log_level: Log level associated to the file log. :param log_file_name: If set, then the file log is written to this file. Otherwise a new log file will be created in the log directory returned by :attr:`Settings.log_dir <pm.settings.__Settings.log_dir>`. """ if log_file_name is None: log_directory = Settings.log_dir name = "pm_logging{}.log".format( datetime.now().strftime("%Y_%m_%d_%H_%M_%S")) log_file_name = os.path.join(log_directory, name) Logger.set_file_logging_level(file_log_level) Logger.set_log_file(log_file_name) Logger.set_console_logging_level(console_log_level) Logger.init() Logger.info("Logging to {} file.".format(log_file_name))
def __load_video(self, video_raw: cv2.VideoCapture): if not video_raw.isOpened(): Logger.error("Unable to read {} feed".format(self.video_path)) self.frames = [] num_video_frames = int(video_raw.get(cv2.CAP_PROP_FRAME_COUNT)) if self.end_frame is None or self.end_frame > num_video_frames: Logger.warning("Setting end_frame to {}".format(num_video_frames)) self.end_frame = num_video_frames num_frames = 0 # Skip the first frames until the self_start frame. video_raw.set(cv2.CAP_PROP_POS_FRAMES, self.start_frame) Logger.info("Loading {} frames...".format(self.end_frame - self.start_frame)) bar = progressbar.ProgressBar(maxval=self.num_frames, widgets=[ progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage() ]) bar.start() for i in range(self.end_frame - self.start_frame): ret = video_raw.grab() if not ret: Logger.error( "Could not load frame {}".format(i + self.start_frame)) raise ValueError( "Could not load frame {}".format(i + self.start_frame)) self.frames.append(video_raw.retrieve()[1]) num_frames += 1 bar.update(num_frames) bar.finish() video_raw.release()
def __del__(self): Logger.info("Deleting inference object") if hasattr(self, 'sess'): self.sess.close()
def download_oasi_data(custom_params: dict = None) -> None: """Downloads all the data specified in the passed argument to the data folder. :Example: .. code-block:: python domains = ['meteo', 'air'] years = range(2000, 2018) download_params = { "domains": domains, "years": years } download_oasi_data(download_params) :param custom_params: Dictionary of custom params to be used to download the data. """ if custom_params is None: custom_params = {} params = { "domains": ["air", "meteo"], "years": range(2000, 2018), "data_directory": pm.Settings.data_dir, "overwrite": False, "ignore_locations": ["Stabio_16"] # Ignore this location, as it is downloaded # thorough the Oasi-Client interface which offers multiple temperature sensors. } params.update(custom_params) # Log the parameters being used. logger_msg = "Downloading oasi data with following params:" align = max([len(name) for name in params]) + 4 for name, value in params.items(): logger_msg += "\n{:>{align}}: {}".format(name, value, align=align) Logger.info(msg=logger_msg) domains = params["domains"] years = params["years"] data_directory = params["data_directory"] overwrite = params["overwrite"] if len(domains) == 0: raise RuntimeError("Domains passed to `download_oasi_data` is empty!") if not os.path.exists(data_directory): os.makedirs(data_directory, exist_ok=True) for dom in domains: Logger.info("Downloading domain {}".format(dom)) dom_path = os.path.join(data_directory, dom) os.makedirs(dom_path, exist_ok=True) domain = requests.get( 'http://www.oasi.ti.ch/web/rest/parameters?domain=' + dom) domain_features = json.loads(domain.text) for feature in domain_features: feature_path = os.path.join(dom_path, feature['code']) Logger.info("Downloading feature {}/{}".format( dom, feature["code"])) os.makedirs(feature_path, exist_ok=True) # Get locations associated to the features. locations = requests.get( 'http://www.oasi.ti.ch/web/rest/locations?domain=' + dom + '¶meter=' + feature['code']) locations = json.loads(locations.text) for loc in locations: if loc['name'] + "_" + loc['code'] in params[ "ignore_locations"]: Logger.warning( "Ignoring {} location".format(loc['name'] + "_" + loc['code'])) continue loc_path = os.path.join(feature_path, loc['name'] + "_" + loc['code']) os.makedirs(loc_path, exist_ok=True) for year in years: csv_file_name = os.path.join(loc_path, str(year) + '.csv') # If the file already exists, then continue to next data without # overwriting. if not overwrite and os.path.exists(csv_file_name): Logger.debug( "File {} already existing. Skipping to next " "file".format(csv_file_name)) continue Logger.debug("Requesting {}.{}.{}.{}".format( dom, feature["code"], loc['name'], year)) locations = requests.get( 'http://www.oasi.ti.ch/web/rest/measure/csv?domain=' + dom + '&resolution=h¶meter=' + feature['code'] + '&from=' + str(year) + '-01-01&to=' + str(year) + '-12-31&location=' + loc['code']) first_line = locations.text.split('\n', 1)[0] if first_line == '# GENERALE': write_csv_file(csv_file_name, locations) else: Logger.debug("Request was not successful!")
def __del__(self): Logger.info("Deleting inference object") self.sess.close()
def __save_module_dataset(self): """Saves the data to the directory selected when opening the file explorer.""" self.progress_bar_all_frames.setEnabled(True) self.progress_bar_intra_frame.setEnabled(True) button_reply = QtWidgets.QMessageBox.question(self, 'Save dataset', "Want to save dataset to {}?".format(self.output_directory), QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No, QtWidgets.QMessageBox.No) if button_reply == QtWidgets.QMessageBox.No: Logger.warning("Rejected directory <{}> for saving all images".format(self.output_directory)) self.output_directory = None self.__save_module_dataset() else: Logger.info("Saving all images to <{}>".format(self.output_directory)) Logger.warning("If dialog freezes, check log file, but DON'T close the window!") working_modules_output_dir = os.path.join(self.output_directory, "working") broken_modules_output_dir = os.path.join(self.output_directory, "broken") misdetected_modules_output_dir = os.path.join(self.output_directory, "misdetected") overall_iter = 0 def save_modules_into_directory(module_dict: dict, directory: str): global overall_iter os.mkdir(os.path.abspath(directory)) for module_number, (module_id, registered_modules) in enumerate(module_dict.items()): Logger.debug("Saving all views of module ID {}: view {}/{}".format(module_id, module_number, len(module_dict.keys()) - 1)) self.progress_bar_all_frames.setValue(self.progress_bar_all_frames.value() + 1) self.progress_bar_intra_frame.setValue(0) self.progress_bar_intra_frame.setMaximum(len(registered_modules)) for m_index, m in enumerate(registered_modules): name = "id_{0:05d}_frame_{1:05d}.jpg".format(module_id, m["frame_id"]) path = os.path.join(directory, name) img = cv2.cvtColor(m["image"], cv2.COLOR_RGB2BGR) cv2.imwrite(path, img) self.progress_bar_intra_frame.setValue(m_index + 1) Logger.info("Saving working modules to <{}>".format(working_modules_output_dir)) save_modules_into_directory(self.working_modules, working_modules_output_dir) Logger.info("Saved all working modules to <{}>".format(working_modules_output_dir)) Logger.info("Saving broken modules to <{}>".format(broken_modules_output_dir)) save_modules_into_directory(self.broken_modules, broken_modules_output_dir) Logger.info("Saved all broken modules to <{}>".format(broken_modules_output_dir)) Logger.info("Saving misdetected modules to <{}>".format(misdetected_modules_output_dir)) save_modules_into_directory(self.misdetected_modules, misdetected_modules_output_dir) Logger.info("Saved all misdetected modules to <{}>".format(misdetected_modules_output_dir)) _ = QtWidgets.QMessageBox.information(self, "Saved!", "Saved all modules to {}".format(self.output_directory), QtWidgets.QMessageBox.Ok) self.close()
def __load_params(self) -> None: """Load the parameters related to camera.""" self.camera = Camera(camera_path=self.camera_param_file) Logger.info("Using camera parameters:\n{}".format(self.camera))