def result_mapping(folder_models, path_datatest): """ Create the U-net. Input : folder_models : path to the folder containing all the model folders to test. path_datatest : path to the folder containing the image to segment. Output : None. Save the segmented images in the data_test folder. """ model_folders = [f for f in folder_models.iterdir()] for root in model_folders: if 'DS_Store' not in root: subpath_model = folder_models / root filename = '/config_network.json' with open(subpath_model / filename, 'r') as fd: config_network = json.loads(fd.read()) axon_segmentation(path_datatest, subpath_model, config_network, segmentations_filenames='segmentation_' + root + '.png') return 'segmented'
def result_mapping(folder_models, path_datatest): """ Create the U-net. Input : folder_models : string : path to the folder containing all the models folders to test. path_datatest : string : path to the folder containing the image to segment. Output : None. Save the segmented images in the data_test folder. """ for root in os.listdir(folder_models)[:]: if 'DS_Store' not in root: subpath_model = os.path.join(folder_models, root) filename = '/config_network.json' with open(subpath_model + filename, 'r') as fd: config_network = json.loads(fd.read()) axon_segmentation(path_datatest, subpath_model, config_network, segmentations_filenames='segmentation_' + root + '.png') return 'segmented'
def segment_image(path_testing_image, path_model, overlap_value, config, resolution_model, segmented_image_prefix, acquired_resolution=0.0, verbosity_level=0): ''' Segment the image located at the path_testing_image location. :param path_testing_image: the path of the image to segment. :param path_model: where to access the model :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param segmented_image_prefix: the prefix to add before the segmented image. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' if os.path.exists(path_testing_image): # Extracting the image name and its folder path from the total path. tmp_path = path_testing_image.split('/') acquisition_name = tmp_path[-1] path_acquisition = '/'.join(tmp_path[:-1]) # Performing the segmentation segmented_image_name = segmented_image_prefix + acquisition_name axon_segmentation(path_acquisitions_folders=path_acquisition, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=segmented_image_name, resampled_resolutions=resolution_model, verbosity_level=verbosity_level, acquired_resolution=acquired_resolution, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: print "Image {0} segmented.".format(path_testing_image) else: print "The path {0} does not exist.".format(path_testing_image) return None
def segment_image(path_testing_image, path_model, overlap_value, config, resolution_model, acquired_resolution = None, verbosity_level=0): ''' Segment the image located at the path_testing_image location. :param path_testing_image: the path of the image to segment. :param path_model: where to access the model :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' # If string, convert to Path objects path_testing_image = convert_path(path_testing_image) path_model = convert_path(path_model) if path_testing_image.exists(): # Extracting the image name and its folder path from the total path. path_parts = path_testing_image.parts acquisition_name = Path(path_parts[-1]) path_acquisition = Path(*path_parts[:-1]) # Get type of model we are using selected_model = path_model.name img_name_original = acquisition_name.stem # Performing the segmentation axon_segmentation(path_acquisitions_folders=path_acquisition, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, resampled_resolutions=resolution_model, verbosity_level=verbosity_level, acquired_resolution=acquired_resolution, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: print(("Image {0} segmented.".format(path_testing_image))) else: print(("The path {0} does not exist.".format(path_testing_image))) return None
def predict_loop(path_img, modelsname, acquired_resolution=0.004, resampled_resolutions=0.004): path_folder, file_name = os.path.split(path_img) if not os.path.exists(path_folder + '/prediction/'): os.makedirs(path_folder + '/prediction/') if os.path.isfile(path_folder + '/prediction/' + file_name.split('.')[0] + '_prediction.png'): print('exists, skip') else: tf.reset_default_graph() model_name = 'models/' + modelsname path_model = os.path.join(model_name) path_configfile = os.path.join(path_model, 'config_network.json') with open(path_configfile, 'r') as fd: config_network = json.loads(fd.read()) prediction = axon_segmentation( path_folder, file_name, path_model, config_network, verbosity_level=3, resampled_resolutions=resampled_resolutions, acquired_resolution=acquired_resolution) print(path_folder + '/prediction/' + file_name.split('.')[0] + '_prediction.png') imsave( path_folder + '/prediction/' + file_name.split('.')[0] + '_prediction.png', prediction[0])
def run(data): path_testing = data.get('path_testing') if data.get('model') == 'SVM': model_name = 'default_SEM_model_v1' else: model_name = 'default_TEM_model_v1' image_name = data.get('image_name') path_model = os.path.join('./AxonDeepSeg/models',model_name) path_configfile = os.path.join(path_model,'config_network.json') if not os.path.exists(path_model): os.makedirs(path_model) with open(path_configfile, 'r') as fd: config_network = json.loads(fd.read()) prediction = axon_segmentation(path_testing, image_name, path_model, config_network,verbosity_level=0) print("all done no errors")
def segment_folders(path_testing_images_folder, path_model, overlap_value, config, resolution_model, segmented_image_suffix, acquired_resolution = 0.0, verbosity_level=0): ''' Segments the images contained in the image folders located in the path_testing_images_folder. :param path_testing_images_folder: the folder where all image folders are located (the images to segment are located in those image folders) :param path_model: where to access the model. :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param segmented_image_suffix: the prefix to add before the segmented image. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' # We loop over all image folders in the specified folded and we segment them one by one. # We loop through every file in the folder as we look for an image to segment for file_ in tqdm(os.listdir(path_testing_images_folder), desc="Segmentation..."): # We segment the image only if it's not already a segmentation. len_suffix = len(segmented_image_suffix)+4 # +4 for ".png" if (file_[-4:] == ".png") and (not (file_[-len_suffix:] == (segmented_image_suffix+'.png'))): # Performing the segmentation basename = file_.split('.') basename.pop() # We remove the extension. basename = ".".join(basename) segmented_image_name = basename + segmented_image_suffix + '.png' axon_segmentation(path_acquisitions_folders=path_testing_images_folder, acquisitions_filenames=[file_], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=[segmented_image_name], acquired_resolution=acquired_resolution, verbosity_level=verbosity_level, resampled_resolutions=resolution_model, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: print "Image {0} segmented.".format(os.path.join(path_testing_images_folder, file_)) # The segmentation has been done for this image folder, we go to the next one. return None
def integrity_test(): try: # get path of directory where AxonDeepSeg was installed dir_path = Path(__file__).resolve().parent # input parameters path = Path('folder_name') / 'file_name' path_testing = dir_path / 'data_test' model_name = 'default_SEM_model' path_model = dir_path / 'models' / model_name path_configfile = path_model / 'config_network.json' # Read the configuration file print('Reading test configuration file.') if not path_model.exists(): path_model.mkdir(parents=True) with open(path_configfile, 'r') as fd: config_network = json.loads(fd.read()) # Launch the axon and myelin segmentation on test image sample provided in the installation print('Computing the segmentation of axon and myelin on test image.') prediction = axon_segmentation([path_testing], ["image.png"], path_model, config_network, prediction_proba_activate=True, verbosity_level=4) # Read the ground truth mask and the obtained segmentation mask mask = ads.imread(path_testing / 'mask.png') pred = ads.imread(path_testing / 'AxonDeepSeg.png') # Generate separate axon and myelin masks of the segmentation output print('Generating axon and myelin segmentation masks and saving.') gt_axon = mask > 200 # Generate binary image with the axons for the ground truth (myelin=127, axon=255) gt_myelin = np.logical_and(mask >= 50, mask <= 200) # Generate binary image with the myelin for the ground truth (myelin=127, axon=255) pred_axon = pred > 200 # Generate binary image with the axons for the segmentation (myelin=127, axon=255) pred_myelin = np.logical_and(pred >= 50, pred <= 200) # Generate binary image with the myelin for the segmentation (myelin=127, axon=255) # Compute Dice between segmentation and ground truth, for both axon and myelin dice_axon = pw_dice(pred_axon, gt_axon) dice_myelin = pw_dice(pred_myelin, gt_myelin) # If all the commands above are executed without bugs, the installation is done correctly print("* * * Integrity test passed. AxonDeepSeg is correctly installed. * * * ") return 0 except IOError: # Else, there is a problem in the installation print("Integrity test failed... ") return -1
def map_model_to_images(folder_model, path_datatests, batch_size=1, gps=0.1, crop_value=25, gpu_per=1.0): """ Apply one trained model to all the specified images """ # Load config with open(os.path.join(folder_model, 'config_network.json'), 'r') as fd: config_network = json.loads(fd.read()) path_images = [ os.path.join(path_datatests, e) for e in os.listdir(path_datatests)[:] if os.path.isdir(os.path.join(path_datatests, e)) ] n_images = len(path_images) path_images_list = list(segment_list(path_images, 20)) if type(gps) != list: gps = n_images * [gps] gps_list = list(segment_list(gps, 20)) for i, path_images_iter in enumerate(path_images_list): gps_iter = gps_list[i] axon_segmentation(path_images_iter, folder_model, config_network, segmentations_filenames='segmentation.png', inference_batch_size=batch_size, write_mode=True, prediction_proba_activate=False, resampled_resolutions=gps_iter, overlap_value=crop_value, gpu_per=gpu_per)
path_testing = "../AxonDeepSeg/data_test/" model_name = 'default_SEM_model_v1' path_model = '../AxonDeepSeg/models/' + model_name path_configfile = path_model + '/config_network.json' if not os.path.exists(path_model): os.makedirs(path_model) with open(path_configfile, 'r') as fd: config_network = json.loads(fd.read()) from AxonDeepSeg.apply_model import axon_segmentation prediction = axon_segmentation([path_testing], ["image.png"], path_model, config_network, verbosity_level=0) mask = imread(path_testing + '/mask.png', flatten=True) pred = imread(path_testing + '/AxonDeepSeg.png', flatten=True) gt_axon = mask > 200 gt_myelin = np.logical_and(mask >= 50, mask <= 200) pred_axon = pred > 200 pred_myelin = np.logical_and(pred >= 50, pred <= 200) dice_axon = pw_dice(pred_axon, gt_axon) dice_myelin = pw_dice(pred_myelin, gt_myelin) print "* * * Integrity test passed. AxonDeepSeg is correctly installed. * * * "
def segment_image(path_testing_image, path_model, overlap_value, config, resolution_model, segmented_image_prefix, acquired_resolution=0.0, verbosity_level=0): ''' Segment the image located at the path_testing_image location. :param path_testing_image: the path of the image to segment. :param path_model: where to access the model :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param segmented_image_prefix: the prefix to add before the segmented image. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' if os.path.exists(path_testing_image): # Extracting the image name and its folder path from the total path. tmp_path = path_testing_image.split('/') acquisition_name = tmp_path[-1] path_acquisition = '/'.join(tmp_path[:-1]) # Get type of model we are using tmp_path, selected_model = os.path.split(path_model) # Read image img = imageio.imread(os.path.join(path_acquisition, acquisition_name)) # Generate tmp file fp = tempfile.NamedTemporaryFile(dir=path_acquisition, suffix='.png', mode='wb') img_name_original, file_extension = os.path.splitext(acquisition_name) if selected_model == "default_TEM_model_v1": imageio.imwrite(fp, 255 - img, format='png') else: imageio.imwrite(fp, img, format='png') tmp_path, tmp_name = os.path.split(fp.name) acquisition_name = tmp_name segmented_image_name = img_name_original + '_seg-axonmyelin' + '.png' # Performing the segmentation axon_segmentation(path_acquisitions_folders=path_acquisition, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=segmented_image_name, resampled_resolutions=resolution_model, verbosity_level=verbosity_level, acquired_resolution=acquired_resolution, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: print "Image {0} segmented.".format(path_testing_image) else: print "The path {0} does not exist.".format(path_testing_image) # Remove temporary file used for the segmentation fp.close() return None
def segment_folders(path_testing_images_folder, path_model, overlap_value, config, resolution_model, segmented_image_suffix, acquired_resolution=0.0, verbosity_level=0): ''' Segments the images contained in the image folders located in the path_testing_images_folder. :param path_testing_images_folder: the folder where all image folders are located (the images to segment are located in those image folders) :param path_model: where to access the model. :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param segmented_image_suffix: the prefix to add before the segmented image. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' # Update list of images to segment by selecting only image files (not already segmented or not masks) img_files = [ file for file in os.listdir(path_testing_images_folder) if (file.endswith(('.png', '.jpg', '.jpeg', '.tif', '.tiff')) and ( not file.endswith(('_seg-axonmyelin.png', '_seg-axon.png', '_seg-myelin.png', 'mask.png')))) ] # Pre-processing: convert to png if not already done and adapt to model contrast for file_ in tqdm(img_files, desc="Segmentation..."): tmp_path, selected_model = os.path.split(path_model) # Read image for conversion img = imageio.imread(os.path.join(path_testing_images_folder, file_)) # Generate tmpfile for segmentation pipeline fp = tempfile.NamedTemporaryFile(dir=path_testing_images_folder, suffix='.png', mode='wb') img_name_original, file_extension = os.path.splitext(file_) if selected_model == "default_TEM_model_v1": imageio.imwrite(fp, 255 - img, format='png') else: imageio.imwrite(fp, img, format='png') tmp_path, tmp_name = os.path.split(fp.name) acquisition_name = tmp_name segmented_image_name = img_name_original + '_seg-axonmyelin' + '.png' axon_segmentation(path_acquisitions_folders=path_testing_images_folder, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=[segmented_image_name], acquired_resolution=acquired_resolution, verbosity_level=verbosity_level, resampled_resolutions=resolution_model, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: tqdm.write("Image {0} segmented.".format( os.path.join(path_testing_images_folder, file_))) # Remove temporary file used for the segmentation fp.close() return None
def generate_statistics(path_model_folder, path_images_folder, resampled_resolution, overlap_value, verbosity_level=0): """ Generates the implemented statistics for all the checkpoints of a given model, for each requested image. :param path_model_folder: Path to the model to use. :param path_images_folder: Path to the folders that contain the images to compute the metrics on. :param resampled_resolution: Float, the resolution to resample to to make the predictions. :param overlap_value: Int, the number of pixels to use for overlap. :param verbosity_level: Int. The higher, the more displayed information. :return: """ model_statistics_dict = {"date": time.strftime("%Y-%m-%d"), "data": {}} # First we load the network parameters from the config file with open(os.path.join(path_model_folder, 'config_network.json'), 'r') as fd: config_network = json.loads(fd.read()) n_classes = config_network['n_classes'] model_name = path_model_folder.split("/")[ -2] # Extraction of the name of the model. # We loop over all checkpoint files to compute statistics for each checkpoint. for checkpoint in os.listdir(path_model_folder): if checkpoint[-10:] == '.ckpt.meta': result_model = {} name_checkpoint = checkpoint[:-10] result_model.update({ 'id_model': model_name, 'ckpt': name_checkpoint, 'config': config_network }) # 1/ We load the saved training statistics, which are independent of the testing images try: f = open(path_model_folder + '/' + name_checkpoint + '.pkl', 'r') res = pickle.load(f) acc_stats = res['accuracy'] loss_stats = res['loss'] epoch_stats = res['steps'] except: print 'No stats file found...' #f = open(path_model_folder + '/evolution.pkl', 'r') #res = pickle.load(f) #epoch_stats = max(res['steps']) #acc_stats = np.mean(res['accuracy'][-10:]) #loss_stats = np.mean(res['loss'][-10:]) epoch_stats = None acc_stats = None loss_stats = None result_model.update({ 'training_stats': { 'training_epoch': epoch_stats, 'training_mvg_avg10_acc': acc_stats, 'training_mvg_avg10_loss': loss_stats }, 'testing_stats': {} }) # 2/ Computation of the predictions / outputs of the network for each image at the same time. predictions, outputs_network = axon_segmentation( path_images_folder, ['image.png'] * len(path_images_folder), path_model_folder, config_network, ckpt_name=name_checkpoint, overlap_value=overlap_value, resampled_resolutions=[resampled_resolution] * len(path_images_folder), prediction_proba_activate=True, write_mode=False, gpu_per=1.0, verbosity_level=verbosity_level) # These two variables are list, as long as the number of images that are tested. if verbosity_level >= 2: print 'Statistics extraction...' # 3/ Computation of the statistics for each image. for i, image_folder in tqdm(enumerate(path_images_folder)): current_prediction = predictions[i] current_network_output = outputs_network[i] # Reading the images and processing them mask_raw = imread(os.path.join(image_folder, 'mask.png'), flatten=True, mode='L') mask = labellize(mask_raw) # We infer the name of the different files name_image = image_folder.split('/')[-1] # Computing metrics and storing them in the json file. current_proba = output_network_to_proba( current_network_output, n_classes) testing_stats_dict = compute_metrics(current_prediction, current_proba, mask, n_classes) result_model['testing_stats'].update( {name_image: testing_stats_dict}) # We add the metrics for all the checkpoints from this model (on all images) to the data list. model_statistics_dict["data"].update( {name_checkpoint: result_model}) return model_statistics_dict
def segment_image(path_testing_image, path_model, overlap_value, config, resolution_model, acquired_resolution = None, verbosity_level=0): ''' Segment the image located at the path_testing_image location. :param path_testing_image: the path of the image to segment. :param path_model: where to access the model :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' # If string, convert to Path objects path_testing_image = convert_path(path_testing_image) path_model = convert_path(path_model) if path_testing_image.exists(): # Extracting the image name and its folder path from the total path. path_parts = path_testing_image.parts acquisition_name = Path(path_parts[-1]) path_acquisition = Path(*path_parts[:-1]) # Get type of model we are using selected_model = path_model.name # Read image img = imageio.imread(str(path_testing_image)) # Generate tmp file fp = open(path_acquisition / '__tmp_segment__.png', 'wb+') img_name_original = acquisition_name.stem if selected_model == "default_TEM_model_v1": imageio.imwrite(fp,255-img, format='png') else: imageio.imwrite(fp, img, format='png') acquisition_name = Path(fp.name).name segmented_image_name = img_name_original + '_seg-axonmyelin' + '.png' # Performing the segmentation axon_segmentation(path_acquisitions_folders=path_acquisition, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=segmented_image_name, resampled_resolutions=resolution_model, verbosity_level=verbosity_level, acquired_resolution=acquired_resolution, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: print(("Image {0} segmented.".format(path_testing_image))) # Remove temporary file used for the segmentation fp.close() (path_acquisition / '__tmp_segment__.png').unlink() else: print(("The path {0} does not exist.".format(path_testing_image))) return None
def segment_folders(path_testing_images_folder, path_model, overlap_value, config, resolution_model, acquired_resolution = None, verbosity_level=0): ''' Segments the images contained in the image folders located in the path_testing_images_folder. :param path_testing_images_folder: the folder where all image folders are located (the images to segment are located in those image folders) :param path_model: where to access the model. :param overlap_value: the number of pixels to be used for overlap when doing prediction. Higher value means less border effects but more time to perform the segmentation. :param config: dict containing the configuration of the network :param resolution_model: the resolution the model was trained on. :param verbosity_level: Level of verbosity. The higher, the more information is given about the segmentation process. :return: Nothing. ''' # If string, convert to Path objects path_testing_images_folder = convert_path(path_testing_images_folder) path_model = convert_path(path_model) # Update list of images to segment by selecting only image files (not already segmented or not masks) img_files = [file for file in path_testing_images_folder.iterdir() if (file.suffix.lower() in ('.png','.jpg','.jpeg','.tif','.tiff')) and (not str(file).endswith(('_seg-axonmyelin.png','_seg-axon.png','_seg-myelin.png','mask.png')))] # Pre-processing: convert to png if not already done and adapt to model contrast for file_ in tqdm(img_files, desc="Segmentation..."): print(path_testing_images_folder / file_) try: height, width, _ = imageio.imread(str(path_testing_images_folder / file_)).shape except: try: height, width = imageio.imread(str(path_testing_images_folder / file_)).shape except Exception as e: raise e image_size = [height, width] minimum_resolution = config["trainingset_patchsize"] * resolution_model / min(image_size) if acquired_resolution < minimum_resolution: print("EXCEPTION: The size of one of the images ({0}x{1}) is too small for the provided pixel size ({2}).\n".format(height, width, acquired_resolution), "The image size must be at least {0}x{0} after resampling to a resolution of {1} to create standard sized patches.\n".format(config["trainingset_patchsize"], resolution_model), "One of the dimensions of the image has a size of {0} after resampling to that resolution.\n".format(round(acquired_resolution * min(image_size) / resolution_model)), "Image file location: {0}".format(str(path_testing_images_folder / file_)) ) sys.exit(2) selected_model = path_model.name # Read image for conversion img = imageio.imread(str(path_testing_images_folder / file_)) # Generate tmpfile for segmentation pipeline fp = open(path_testing_images_folder / '__tmp_segment__.png', 'wb+') img_name_original = file_.stem if selected_model == "default_TEM_model_v1": imageio.imwrite(fp,255-img, format='png') else: imageio.imwrite(fp,img, format='png') acquisition_name = Path(fp.name).name segmented_image_name = img_name_original + '_seg-axonmyelin' + '.png' axon_segmentation(path_acquisitions_folders=path_testing_images_folder, acquisitions_filenames=[acquisition_name], path_model_folder=path_model, config_dict=config, ckpt_name='model', inference_batch_size=1, overlap_value=overlap_value, segmentations_filenames=[segmented_image_name], acquired_resolution=acquired_resolution, verbosity_level=verbosity_level, resampled_resolutions=resolution_model, prediction_proba_activate=False, write_mode=True) if verbosity_level >= 1: tqdm.write("Image {0} segmented.".format(str(path_testing_images_folder / file_))) # Remove temporary file used for the segmentation fp.close() (path_testing_images_folder / '__tmp_segment__.png').unlink() return None
def integrity_test(): try: import json import os from AxonDeepSeg.testing.segmentation_scoring import * from time import time from AxonDeepSeg.apply_model import axon_segmentation from scipy.misc import imread, imsave # get path of directory where AxonDeepSeg was installed dir_path = os.path.dirname(os.path.abspath(__file__)) # input parameters path = os.path.join('folder_name', 'file_name') path_testing = os.path.join(dir_path, 'data_test') model_name = 'default_SEM_model_v1' path_model = os.path.join(dir_path, 'models', model_name) path_configfile = os.path.join(path_model, 'config_network.json') # Read the configuration file print('Reading test configuration file.') if not os.path.exists(path_model): os.makedirs(path_model) with open(path_configfile, 'r') as fd: config_network = json.loads(fd.read()) # Launch the axon and myelin segmentation on test image sample provided in the installation print('Computing the segmentation of axon and myelin on test image.') prediction = axon_segmentation([path_testing], ["image.png"], path_model, config_network, verbosity_level=0) # Read the ground truth mask and the obtained segmentation mask mask = imread(path_testing + '/mask.png', flatten=True) pred = imread(path_testing + '/AxonDeepSeg.png', flatten=True) # Generate separate axon and myelin masks of the segmentation output print('Generating axon and myelin segmentation masks and saving.') gt_axon = mask > 200 # Generate binary image with the axons for the ground truth (myelin=127, axon=255) gt_myelin = np.logical_and( mask >= 50, mask <= 200 ) # Generate binary image with the myelin for the ground truth (myelin=127, axon=255) pred_axon = pred > 200 # Generate binary image with the axons for the segmentation (myelin=127, axon=255) pred_myelin = np.logical_and( pred >= 50, pred <= 200 ) # Generate binary image with the myelin for the segmentation (myelin=127, axon=255) # Compute Dice between segmentation and ground truth, for both axon and myelin dice_axon = pw_dice(pred_axon, gt_axon) dice_myelin = pw_dice(pred_myelin, gt_myelin) # If all the commands above are executed without bugs, the installation is done correctly print( "* * * Integrity test passed. AxonDeepSeg is correctly installed. * * * " ) return 0 except IOError: # Else, there is a problem in the installation print("Integrity test failed... ") return -1
# $ cd AxonSegmentation/AxonDeepSeg # $ python learn_model.py -p path_bireli_training -m path_bireli_model_new -lr 0.0005 # or # $ python learn_model.py -p path_bireli_training -m path_bireli_model_new -m_init path_bireli_model_init -lr 0.0005 #- In a new window to visualize the training performances # $ scp -r path_bireli_model_new path_model_new # #----------------------Training the MRF from the paths_training---------------------# from AxonDeepSeg.mrf import learn_mrf learn_mrf(paths_training, path_mrf) #----------------------Axon segmentation with a trained model and trained mrf---------------------# from AxonDeepSeg.apply_model import axon_segmentation axon_segmentation(path_my_data, path_model, path_mrf) #----------------------Myelin segmentation from Axon segmentation--------------------# from AxonDeepSeg.apply_model import myelin myelin(path_my_data) #----------------------Axon and Myelin segmentation--------------------# from AxonDeepSeg.apply_model import pipeline pipeline(path_my_data,path_model,path_mrf) #----------------------Visualization of the results--------------------# from AxonDeepSeg.evaluation.visualization import visualize_results visualize_results(path_my_data)