Exemple #1
0
 def notify(self, meta):
     self.meta_df = meta.data_df
     self.write_df_to_csv(self.name,
                          'LAST_TRUE')  # Save new meta when updated
     if DrawingParams.draw_accepted:
         dict_format = pdu.from_dataframe_to_dict(self.meta_df)
         visu.draw_partition(dict_format, int(os.environ['img_w']),
                             meta.info_name, self.curr_window_dir)
Exemple #2
0
    def final_merge_loop(self):
        flag = True
        check_ = 0
        counter = 0
        if not self.data_processing.pairs_to_consider:
            return
        while flag:
            counter += 1
            break_to_while = False
            if not self.data_processing.pairs_to_consider:
                break

            for index, pair in enumerate(self.data_processing.pairs_to_consider):
                self.cur_iter_name = str(counter) + '_' + str(pair)
                logging.debug('pair {} '.format(pair))
                if break_to_while:
                    check_ = 0
                    break
                self.accepted = False
                self.merge_move(final_merge=True,
                                pair=pair)
                if self.proposed_partition is None:
                    if check_ >= len(self.data_processing.pairs_to_considercleaned) ** 2:
                        break_to_while = False
                        flag = False
                        break
                    else:
                        check_ += 1
                        continue
                self.acc_obj.propose(self.proposed_partition[['frame_no', 'id']].values,
                                     pdu.get_particular_states(self.proposed_partition,
                                                               self.change_track[
                                                                   'new']))

                accepted_count = self.acc_obj.analyse_acceptance(self.change_track)
                ratio = max(list(
                    self.acc_obj.ratio.values()))
                if DrawingParams.draw_every_iteration:
                    current = pdu.from_dataframe_to_dict(self.meta_partition.data_df)
                    visu.draw_partition(current, int(os.environ.get('img_w')),
                                        'partitions_iteration_{}_{}_'.format(self.cur_iter_name,
                                                                             "current_"),
                                        self.files_.curr_window_dir)

                if accepted_count >= AcceptanceParams.number_of_acc_for_acc:
                    self.acc_obj.accepted_(change_track=self.change_track)
                    self.meta_partition.data_df = self.proposed_partition
                    self.acc_update()
                    break_to_while = True
                if break_to_while:
                    check_ = 0
                    break
                check_ += 1
                if not break_to_while and check_ >= len(self.data_processing.pairs_to_consider):
                    flag = False
Exemple #3
0
    def load_info(self):
        files = os.listdir(self.files_dir)
        for file in files:
            file_path = os.path.join(args.files_dir, file)
            if file.endswith('json'):
                curr_file_info = load_and_process(file_path)
                curr_file_info = sort_meta_by_key(curr_file_info)
            elif file.endswith('.csv'):
                meta_pandas = read_multiindex_pd(file_path)
                meta_dict = from_dataframe_to_dict(meta_pandas)
                curr_file_info = fixed_to_original_coordinate_system(
                    meta_dict, self.homography_dict,
                    int(os.environ.get('fixed_coordinate_resize_h')),
                    int(os.environ.get('fixed_coordinate_resize_w')),
                    self.height, self.width)

            else:
                raise ValueError('Check you input file formats!')
            self.files_info[file] = curr_file_info
            self.ids_counters[file] = []
Exemple #4
0
 def get_meta(self):
     final_meta = self.analysis()
     final_meta_dict = pdu.from_dataframe_to_dict(final_meta)
     return final_meta_dict, self.homography