def main(): common.create_directories() print(" Q = ignore image") print(" 1 = label as round") print(" 2 = label as wide") print(" 3 = label as narrow") print("ARROW KEYS = label directions\n") global type_label global direction_label global plt_text unlabeled_imgs = common.get_files(common.SCREENSHOTS_DIR) num_labeled = 0 for path, filename in unlabeled_imgs: print("Processing {}...".format(filename)) img = plt.imread(path) ax = plt.gca() fig = plt.gcf() plot = ax.imshow(img) plt.axis('off') plt.tight_layout() plt_text = plt.text(0, 0, "") fig.canvas.mpl_connect('key_press_event', on_press) mng = plt.get_current_fig_manager() mng.window.state('zoomed') plt.show() if type_label and direction_label: dst_filename = "{}_{}_{}.png".format( type_dictionary[type_label], direction_label, time.strftime("%Y%m%d-%H%M%S")) os.rename(path, common.LABELED_DIR + dst_filename) direction_label = '' type_label = None num_labeled += 1 if len(unlabeled_imgs) > 0: print("\nLabeled {} out of {} images ({}%).".format( num_labeled, len(unlabeled_imgs), 100 * num_labeled // len(unlabeled_imgs))) print("Finished!") else: print("\nThere are no images to label.")
def main(training_set_ratio): common.create_directories() arrows = pd.DataFrame(np.zeros((3, 4), dtype=np.int32), index=('round', 'wide', 'narrow'), columns=('down', 'left', 'right', 'up')) images = [(p, f) for p, f in common.get_files(common.SAMPLES_DIR) if f[-5] != 'F'] if images: for _, filename in images: arrow_direction, arrow_type = common.arrow_labels(filename) arrows[arrow_direction][arrow_type] += 1 num_samples = int(arrows.min().min() * training_set_ratio) print("Samples per type: {}".format(num_samples * 4)) for t, _ in arrows.iterrows(): print("\nProcessing {} arrows...".format(t)) for direction in arrows: candidates = [(p, f) for p, f in images if common.arrow_labels(f) == (direction, t)] print("{}: {}".format(direction, len(candidates))) training = random.sample(candidates, num_samples) for path, filename in training: dst_dir = common.TRAINING_DIR + direction + '/' os.rename(path, dst_dir + filename) os.rename(flipped(path), dst_dir + flipped(filename)) candidates = [c for c in candidates if c not in training] validation = random.sample( candidates, int(len(candidates) * VALIDATION_SET_RATIO)) for path, filename in validation: dst_dir = common.VALIDATION_DIR + direction + '/' os.rename(path, dst_dir + filename) os.rename(flipped(path), dst_dir + flipped(filename)) testing = [c for c in candidates if c not in validation] for path, filename in testing: dst_dir = common.TESTING_DIR + direction + '/' os.rename(path, dst_dir + filename) os.rename(flipped(path), dst_dir + flipped(filename)) show_summary() print("\nFinished!")
def main(): common.create_directories() print("Reverting images from the training directory...") revert_files(common.TRAINING_DIR) print("Reverting images from the validation directory...") revert_files(common.VALIDATION_DIR) print("Reverting images from the testing directory...") revert_files(common.TESTING_DIR) print("Finished!")
def main(): json_message = json.loads(get_message_from_stdin()) try: # just testing connectivity if json_message["native_messaging_host_accessible"]: return except Exception as e: pass output_archive_content = base64.b64decode(json_message["output_archive"]) output_archive_extension = json_message["output_archive_extension"] board = json_message["board"] application_name = json_message["application_name"] try: temporary_directory = os.path.join("tmp", application_name) common.create_directories(temporary_directory) archive_file_path = os.path.join( temporary_directory, application_name + "." + output_archive_extension) with open(archive_file_path, "wb") as archive: archive.write(output_archive_content) dest_path = os.path.join(temporary_directory, application_name) common.create_directories(dest_path) tar = tarfile.open(archive_file_path, "r:gz") for tarinfo in tar: tar.extract(tarinfo, dest_path) tar.close() path_to_makefile = os.path.join(dest_path, "generated_by_riotam", application_name) #open standard terminal and execute shell script "flash" Popen([ "x-terminal-emulator", "-e", "./flash {0} {1}".format(board, path_to_makefile) ]) #rmtree(temporary_directory) except Exception as e: logging.error(str(e), exc_info=True)
def cache(self, path, board, name): create_directories(self._cache_dir) # only store if not in cache already if self.get_entry(board, name) is None: dest_in_cache = os.path.join(self._cache_dir, board, name) copytree(path, dest_in_cache) # show that cached application/module is now ready to use ready_file_path = os.path.join(dest_in_cache, ".ready_to_use") open(ready_file_path, "a").close()
def cache(self, src_path, board, app_dir_name, file_name): create_directories(self._cache_dir) # only store if not in cache already if self.get_entry(board, app_dir_name, file_name) is None: dest_in_cache = os.path.join(self._cache_dir, board, app_dir_name) create_directories(dest_in_cache) logging.debug("CACHING: %s" % file_name) copyfile(src_path, os.path.join(dest_in_cache, file_name)) # show that cached application/module is now ready to use ready_file_path = os.path.join(dest_in_cache, ".ready_to_use") open(ready_file_path, "a").close()
def main(batch_size, model_name): common.create_directories() show_settings(batch_size) model = make_model() training, validation = make_generators(batch_size) fit(model, training, validation, batch_size) save(model, model_name) print("\nFinished!") print("Run " + cf.skyBlue("classify.py") + " to test the model and get information about its performance.") print("More information available with " + cf.orange("Tensorboard") + ".")
def main(argv): parser = init_argparse() try: args = parser.parse_args(argv) except Exception as e: print(str(e)) return home_dir = expanduser("~") try: target_dir = common.get_target_dir(home_dir, args.browser) except common.BrowserNotSupportedException as e: print(str(e)) return # create directory to store native messaging host common.create_directories(target_dir) # copy native messaging host manifest json_manifest_name = "%s.json" % common.HOST_NAME copyfile(os.path.join(CUR_DIR, json_manifest_name), os.path.join(target_dir, json_manifest_name)) # replace HOST_PATH placeholder in the manifest host_path = "%s/riot_app_market.py" % CUR_DIR replace_host_path(os.path.join(target_dir, json_manifest_name), host_path) # set permissions for the manifest so that all users can read it json_manifest = "{0}/{1}".format(target_dir, json_manifest_name) st = os.stat(json_manifest) os.chmod(json_manifest, st.st_mode | stat.S_IROTH) print("Native messaging host {0} has been installed for {1}".format( common.HOST_NAME, args.browser))
def main(src_subdir, verbose, model_name): common.create_directories() src_dir = common.DATA_DIR + src_subdir + "/" model = tensorflow.keras.models.load_model(common.MODEL_DIR + model_name) # real (index) x predicted (column) confusion_matrix = pd.DataFrame(np.zeros((4, 4), dtype=np.int32), index=('down', 'left', 'right', 'up'), columns=('down', 'left', 'right', 'up')) classification_matrix = pd.DataFrame(np.zeros((4, 3)), index=('down', 'left', 'right', 'up'), columns=('precision', 'recall', 'f1')) type_matrix = pd.DataFrame(np.zeros((4, 2), dtype=np.int32), index=('round', 'wide', 'narrow', 'total'), columns=('correct', 'incorrect')) images = common.get_files(src_dir) print("Processing {} file(s) in {}/...\n".format(len(images), src_subdir)) for path, filename in images: img = cv2.imread(path, cv2.IMREAD_GRAYSCALE) data = np.reshape(img, (1, ) + common.INPUT_SHAPE) prediction = model.predict(data) class_index = np.argmax(prediction) predicted_class = common.CLASSES[class_index] real_class, arrow_type = common.arrow_labels(filename) if verbose and real_class != predicted_class: print(path) print("Expected {} but got {}: {}\n".format( cf.lightGreen(real_class), cf.lightCoral(predicted_class), str(prediction[0]))) confusion_matrix[predicted_class][real_class] += 1 if real_class == predicted_class: type_matrix['correct'][arrow_type] += 1 type_matrix['correct']['total'] += 1 else: type_matrix['incorrect'][arrow_type] += 1 type_matrix['incorrect']['total'] += 1 print("\n" + cf.sandyBrown("Confusion matrix")) print(confusion_matrix) classification_matrix['precision'] = confusion_matrix.apply(precision) classification_matrix['recall'] = confusion_matrix.apply(recall, axis=1) classification_matrix['f1'] = classification_matrix.apply(f1, axis=1) print("\n" + cf.skyBlue("Classification summary")) print(classification_matrix) type_matrix['accuracy'] = type_matrix.apply(type_accuracy, axis=1) print("\n" + cf.plum("Accuracy by type")) print(type_matrix) print("\nFinished!")
def main(inspection, mode, automatic): common.create_directories() print(" SPACE = approve") print("OTHER KEYS = skip") print(" Q = quit\n") labeled_imgs = common.get_files(common.LABELED_DIR) approved = 0 for path, filename in labeled_imgs: print("Processing " + cf.skyBlue(path)) arrows = [] display = cv2.imread(path) height, width, _ = display.shape # manually tuned values search_x, search_y = width // 5 + 35, height // 4 search_width, search_height = SEARCH_REGION_WIDTH, height // 2 - search_y for _ in range(4): x0 = search_x x1 = x0 + search_width y0 = search_y y1 = y0 + search_height img = display[y0:y1, x0:x1] (cx, cy), arrow_box = process_arrow(img, mode) search_x += int(cx + ARROW_BOX_DIST - SEARCH_REGION_WIDTH / 2) search_y += int(cy - SEARCH_REGION_HEIGHT / 2) search_width = SEARCH_REGION_WIDTH search_height = SEARCH_REGION_HEIGHT arrows.append(arrow_box) if not automatic: arrow_type, directions, _ = re.split('_', filename) reference = get_reference_arrows(directions, arrows[0].shape) cv2.imshow(arrow_type, np.vstack([np.hstack(arrows), reference])) key = cv2.waitKey() cv2.destroyAllWindows() else: key = APPROVE_KEY if key == APPROVE_KEY: if not inspection: save_arrow_imgs(arrows, filename) approved += 1 elif key == EXIT_KEY: break else: print("Skipped!") if len(labeled_imgs) > 0: print("\nApproved {} out of {} images ({}%).\n".format( approved, len(labeled_imgs), 100 * approved // len(labeled_imgs))) else: print("There are no images to preprocess.\n") show_summary() print("Finished!")