def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_bval_list = arguments.i # Build fname_out if arguments.o is not None: fname_out = arguments.o else: path_in, file_in, ext_in = extract_fname(fname_bval_list[0]) fname_out = path_in + 'bvals_concat' + ext_in # Open bval files and concatenate bvals_concat = '' # for file_i in fname_bval_list: # f = open(file_i, 'r') # for line in f: # bvals_concat += line # f.close() from dipy.data.fetcher import read_bvals_bvecs for i_fname in fname_bval_list: bval_i, bvec_i = read_bvals_bvecs(i_fname, None) bvals_concat += ' '.join(str(v) for v in bval_i) bvals_concat += ' ' # Write new bval new_f = open(fname_out, 'w') new_f.write(bvals_concat) new_f.close()
def main(argv=None): """ Main function :param fname_anat: :param fname_centerline: :param verbose: :return: """ parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_anat = arguments.i fname_centerline = arguments.s # load input images im_anat = Image(fname_anat) im_centerline = Image(fname_centerline) # flatten sagittal im_anat_flattened = flatten_sagittal(im_anat, im_centerline, verbose) # save output fname_out = add_suffix(fname_anat, '_flatten') im_anat_flattened.save(fname_out) display_viewer_syntax([fname_anat, fname_out])
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_in = arguments.bvec fname_out = arguments.o # get bvecs in proper orientation from dipy.io import read_bvals_bvecs bvals, bvecs = read_bvals_bvecs(None, fname_in) # # Transpose bvecs # printv('Transpose bvecs...', verbose) # # from numpy import transpose # bvecs = bvecs.transpose() # Write new file if fname_out == '': path_in, file_in, ext_in = extract_fname(fname_in) fname_out = path_in + file_in + ext_in fid = open(fname_out, 'w') for iLine in range(bvecs.shape[0]): fid.write(' '.join(str(i) for i in bvecs[iLine, :]) + '\n') fid.close() # display message printv('Created file:\n--> ' + fname_out + '\n', verbose, 'info')
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) GYRO = float(42.576 * 10**6) # gyromagnetic ratio (in Hz.T^-1) gradamp = [] bigdelta = [] smalldelta = [] gradamp = arguments.g bigdelta = arguments.b smalldelta = arguments.d # printv(arguments) printv('\nCheck parameters:') printv(' gradient amplitude ..... ' + str(gradamp) + ' mT/m') printv(' big delta .............. ' + str(bigdelta) + ' ms') printv(' small delta ............ ' + str(smalldelta) + ' ms') printv(' gyromagnetic ratio ..... ' + str(GYRO) + ' Hz/T') printv('') bvalue = (2 * math.pi * GYRO * gradamp * 0.001 * smalldelta * 0.001)**2 * (bigdelta * 0.001 - smalldelta * 0.001 / 3) printv('b-value = ' + str(bvalue / 10**6) + ' mm^2/s\n') return bvalue
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # initialization file_mask = '' # Get parser info parser = get_parser() arguments = parser.parse_args(args=None if sys.argv[1:] else ['--help']) fname_in = arguments.i fname_bvals = arguments.bval fname_bvecs = arguments.bvec prefix = arguments.o method = arguments.method evecs = arguments.evecs if arguments.m is not None: file_mask = arguments.m # compute DTI if not compute_dti(fname_in, fname_bvals, fname_bvecs, prefix, method, evecs, file_mask, verbose): printv('ERROR in compute_dti()', 1, 'error')
def main(argv=None): """ Main function :param argv: :return: """ parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # check number of input args if not len(arguments.i) == len(arguments.order): raise Exception( "Number of items between flags '-i' and '-order' should be the same." ) if not len(arguments.bval) == len(arguments.bvec): raise Exception( "Number of files for bval and bvec should be the same.") # Concatenate NIFTI files im_list = [Image(fname) for fname in arguments.i] im_concat = concat_data(im_list, dim=3, squeeze_data=False) im_concat.save(arguments.o) printv("Generated file: {}".format(arguments.o)) # Concatenate bvals and bvecs bvals_concat = '' bvecs_concat = ['', '', ''] i_dwi = 0 # counter for DWI files, to read in bvec/bval files for i_item in range(len(arguments.order)): if arguments.order[i_item] == 'b0': # count number of b=0 n_b0 = Image(arguments.i[i_item]).dim[3] bval = np.array([0.0] * n_b0) bvec = np.array([[0.0, 0.0, 0.0]] * n_b0) elif arguments.order[i_item] == 'dwi': # read bval/bvec files bval, bvec = read_bvals_bvecs(arguments.bval[i_dwi], arguments.bvec[i_dwi]) i_dwi += 1 # Concatenate bvals bvals_concat += ' '.join(str(v) for v in bval) bvals_concat += ' ' # Concatenate bvecs for i in (0, 1, 2): bvecs_concat[i] += ' '.join( str(v) for v in map(lambda n: '%.16f' % n, bvec[:, i])) bvecs_concat[i] += ' ' bvecs_concat = '\n'.join( str(v) for v in bvecs_concat) # transform list into lines of strings # Write files new_f = open(arguments.obval, 'w') new_f.write(bvals_concat) new_f.close() printv("Generated file: {}".format(arguments.obval)) new_f = open(arguments.obvec, 'w') new_f.write(bvecs_concat) new_f.close() printv("Generated file: {}".format(arguments.obvec))
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) printv('Load data...', verbose) nii_mt = Image(arguments.mt) nii_pd = Image(arguments.pd) nii_t1 = Image(arguments.t1) if arguments.b1map is None: nii_b1map = None else: nii_b1map = Image(arguments.b1map) if arguments.trmt is None: arguments.trmt = fetch_metadata( get_json_file_name(arguments.mt, check_exist=True), 'RepetitionTime') if arguments.trpd is None: arguments.trpd = fetch_metadata( get_json_file_name(arguments.pd, check_exist=True), 'RepetitionTime') if arguments.trt1 is None: arguments.trt1 = fetch_metadata( get_json_file_name(arguments.t1, check_exist=True), 'RepetitionTime') if arguments.famt is None: arguments.famt = fetch_metadata( get_json_file_name(arguments.mt, check_exist=True), 'FlipAngle') if arguments.fapd is None: arguments.fapd = fetch_metadata( get_json_file_name(arguments.pd, check_exist=True), 'FlipAngle') if arguments.fat1 is None: arguments.fat1 = fetch_metadata( get_json_file_name(arguments.t1, check_exist=True), 'FlipAngle') # compute MTsat nii_mtsat, nii_t1map = compute_mtsat(nii_mt, nii_pd, nii_t1, arguments.trmt, arguments.trpd, arguments.trt1, arguments.famt, arguments.fapd, arguments.fat1, nii_b1map=nii_b1map) # Output MTsat and T1 maps printv('Generate output files...', verbose) nii_mtsat.save(arguments.omtsat) nii_t1map.save(arguments.ot1map) display_viewer_syntax([arguments.omtsat, arguments.ot1map], colormaps=['gray', 'gray'], minmax=['-10,10', '0, 3'], opacities=['1', '1'], verbose=verbose)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_bvecs_list = arguments.i # Build fname_out if arguments.o is not None: fname_out = arguments.o else: path_in, file_in, ext_in = extract_fname(fname_bvecs_list[0]) fname_out = path_in + 'bvecs_concat' + ext_in # # Open bvec files and collect values # nb_files = len(fname_bvecs_list) # bvecs_all = [] # for i_fname in fname_bvecs_list: # bvecs = [] # with open(i_fname) as f: # for line in f: # bvec_line = map(float, line.split()) # bvecs.append(bvec_line) # bvecs_all.append(bvecs) # f.close() # # Concatenate # bvecs_concat = '' # for i in range(0, 3): # for j in range(0, nb_files): # bvecs_concat += ' '.join(str(v) for v in bvecs_all[j][i]) # bvecs_concat += ' ' # bvecs_concat += '\n' # # Open bvec files and collect values bvecs_all = ['', '', ''] for i_fname in fname_bvecs_list: from dipy.data.fetcher import read_bvals_bvecs bval_i, bvec_i = read_bvals_bvecs(None, i_fname) for i in range(0, 3): bvecs_all[i] += ' '.join( str(v) for v in map(lambda n: '%.16f' % n, bvec_i[:, i])) bvecs_all[i] += ' ' # Concatenate bvecs_concat = '\n'.join(str(v) for v in bvecs_all) # Write new bvec new_f = open(fname_out, 'w') new_f.write(bvecs_concat) new_f.close()
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) param.fname_data = arguments.i arg = 0 if arguments.f is not None: param.new_size = arguments.f param.new_size_type = 'factor' arg += 1 elif arguments.mm is not None: param.new_size = arguments.mm param.new_size_type = 'mm' arg += 1 elif arguments.vox is not None: param.new_size = arguments.vox param.new_size_type = 'vox' arg += 1 elif arguments.ref is not None: param.ref = arguments.ref arg += 1 else: printv( parser.error( 'ERROR: you need to specify one of those three arguments : -f, -mm or -vox' )) if arg > 1: printv( parser.error( 'ERROR: you need to specify ONLY one of those three arguments : -f, -mm or -vox' )) if arguments.o is not None: param.fname_out = arguments.o if arguments.x is not None: if len(arguments.x) == 1: param.interpolation = int(arguments.x) else: param.interpolation = arguments.x spinalcordtoolbox.resampling.resample_file(param.fname_data, param.fname_out, param.new_size, param.new_size_type, param.interpolation, param.verbose, fname_ref=param.ref)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # Get parser info di = arguments.di da = arguments.da db = arguments.db # Compute MSCC MSCC = mscc(di, da, db) # Display results printv('\nMSCC = ' + str(MSCC) + '\n', verbose, 'info')
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_mtr = arguments.o # compute MTR printv('\nCompute MTR...', verbose) nii_mtr = compute_mtr(nii_mt1=Image(arguments.mt1), nii_mt0=Image(arguments.mt0), threshold_mtr=arguments.thr) # save MTR file nii_mtr.save(fname_mtr, dtype='float32') display_viewer_syntax([arguments.mt0, arguments.mt1, fname_mtr])
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) param = Param() fname_src = arguments.i if arguments.o is not None: fname_dst = arguments.o else: fname_dst = add_suffix(fname_src, "_tsnr") # call main function tsnr = Tsnr(param=param, fmri=fname_src, out=fname_dst) tsnr.compute()
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) input_filename = arguments.i if arguments.o is not None: output_filename = arguments.o else: output_filename = add_suffix(input_filename, '_gmseg') use_tta = arguments.t model_name = arguments.m threshold = arguments.thr if threshold > 1.0 or threshold < 0.0: raise RuntimeError("Threshold should be between 0.0 and 1.0.") # Threshold zero means no thresholding if threshold == 0.0: threshold = None from spinalcordtoolbox.deepseg_gm import deepseg_gm deepseg_gm.check_backend() out_fname = deepseg_gm.segment_file(input_filename, output_filename, model_name, threshold, int(verbose), use_tta) path_qc = arguments.qc qc_dataset = arguments.qc_dataset qc_subject = arguments.qc_subject if path_qc is not None: generate_qc(fname_in1=input_filename, fname_seg=out_fname, args=sys.argv[1:], path_qc=os.path.abspath(path_qc), dataset=qc_dataset, subject=qc_subject, process='sct_deepseg_gm') display_viewer_syntax([input_filename, format(out_fname)], colormaps=['gray', 'red'], opacities=['1', '0.7'], verbose=verbose)
def main(argv=None): """ Main function :param args: :return: """ parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # Building the command, do sanity checks fname_in = arguments.i fname_out = arguments.o squeeze_data = bool(arguments.squeeze) # convert file convert(fname_in, fname_out, squeeze_data=squeeze_data)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) from spinalcordtoolbox.reports.qc import generate_qc # Build args list (for display) args_disp = '-i ' + arguments.i if arguments.d: args_disp += ' -d ' + arguments.d if arguments.s: args_disp += ' -s ' + arguments.s generate_qc(fname_in1=arguments.i, fname_in2=arguments.d, fname_seg=arguments.s, args=args_disp, path_qc=arguments.qc, dataset=arguments.qc_dataset, subject=arguments.qc_subject, process=arguments.p)
def main(argv=None): """ Main function :param argv: :return: """ parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) # initialize ImageCropper cropper = ImageCropper(Image(arguments.i)) cropper.verbose = verbose # Switch across cropping methods if arguments.g: cropper.get_bbox_from_gui() elif arguments.m: cropper.get_bbox_from_mask(Image(arguments.m)) elif arguments.ref: cropper.get_bbox_from_ref(Image(arguments.ref)) else: cropper.get_bbox_from_minmax( BoundingBox(arguments.xmin, arguments.xmax, arguments.ymin, arguments.ymax, arguments.zmin, arguments.zmax) ) # Crop image img_crop = cropper.crop(background=arguments.b) # Write cropped image to file if arguments.o is None: fname_out = add_suffix(arguments.i, '_crop') else: fname_out = arguments.o img_crop.save(fname_out) display_viewer_syntax([arguments.i, fname_out])
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # initialization param = ParamMoco(group_size=1, metric='MeanSquares', smooth='0') # Fetch user arguments param.fname_data = arguments.i param.path_out = arguments.ofolder param.remove_temp_files = arguments.r param.interp = arguments.x if arguments.g is not None: param.group_size = arguments.g if arguments.m is not None: param.fname_mask = arguments.m if arguments.param is not None: param.update(arguments.param) # run moco moco_wrapper(param)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # initialization param = ParamMoco(is_diffusion=True, group_size=3, metric='MI', smooth='1') # Fetch user arguments param.fname_data = arguments.i param.fname_bvecs = os.path.abspath(arguments.bvec) param.fname_bvals = arguments.bval param.bval_min = arguments.bvalmin param.group_size = arguments.g param.fname_mask = arguments.m param.interp = arguments.x param.path_out = arguments.ofolder param.remove_temp_files = arguments.r if arguments.param is not None: param.update(arguments.param) # run moco moco_wrapper(param)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) # Default params param = Param() # Get parser info fname_data = arguments.i if arguments.m is not None: fname_mask = arguments.m else: fname_mask = '' method = arguments.method if arguments.vol is not None: index_vol_user = arguments.vol else: index_vol_user = '' # Check parameters if method == 'diff': if not fname_mask: printv('You need to provide a mask with -method diff. Exit.', 1, type='error') # Load data and orient to RPI im_data = Image(fname_data).change_orientation('RPI') data = im_data.data if fname_mask: mask = Image(fname_mask).change_orientation('RPI').data # Retrieve selected volumes if index_vol_user: index_vol = parse_num_list(index_vol_user) else: index_vol = range(data.shape[3]) # Make sure user selected 2 volumes with diff method if method == 'diff': if not len(index_vol) == 2: printv( 'Method "diff" should be used with exactly two volumes (specify with flag "-vol").', 1, 'error') # Compute SNR # NB: "time" is assumed to be the 4th dimension of the variable "data" if method == 'mult': # Compute mean and STD across time data_mean = np.mean(data[:, :, :, index_vol], axis=3) data_std = np.std(data[:, :, :, index_vol], axis=3, ddof=1) # Generate mask where std is different from 0 mask_std_nonzero = np.where(data_std > param.almost_zero) snr_map = np.zeros_like(data_mean) snr_map[mask_std_nonzero] = data_mean[mask_std_nonzero] / data_std[ mask_std_nonzero] # Output SNR map fname_snr = add_suffix(fname_data, '_SNR-' + method) im_snr = empty_like(im_data) im_snr.data = snr_map im_snr.save(fname_snr, dtype=np.float32) # Output non-zero mask fname_stdnonzero = add_suffix(fname_data, '_mask-STD-nonzero' + method) im_stdnonzero = empty_like(im_data) data_stdnonzero = np.zeros_like(data_mean) data_stdnonzero[mask_std_nonzero] = 1 im_stdnonzero.data = data_stdnonzero im_stdnonzero.save(fname_stdnonzero, dtype=np.float32) # Compute SNR in ROI if fname_mask: mean_in_roi = np.average(data_mean[mask_std_nonzero], weights=mask[mask_std_nonzero]) std_in_roi = np.average(data_std[mask_std_nonzero], weights=mask[mask_std_nonzero]) snr_roi = mean_in_roi / std_in_roi # snr_roi = np.average(snr_map[mask_std_nonzero], weights=mask[mask_std_nonzero]) elif method == 'diff': data_2vol = np.take(data, index_vol, axis=3) # Compute mean in ROI data_mean = np.mean(data_2vol, axis=3) mean_in_roi = np.average(data_mean, weights=mask) data_sub = np.subtract(data_2vol[:, :, :, 1], data_2vol[:, :, :, 0]) _, std_in_roi = weighted_avg_and_std(data_sub, mask) # Compute SNR, correcting for Rayleigh noise (see eq. 7 in Dietrich et al.) snr_roi = (2 / np.sqrt(2)) * mean_in_roi / std_in_roi # Display result if fname_mask: printv('\nSNR_' + method + ' = ' + str(snr_roi) + '\n', type='info')
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) parameter = arguments.p remove_temp_files = arguments.r noise_threshold = arguments.d file_to_denoise = arguments.i output_file_name = arguments.o std_noise = arguments.std param = Param() param.verbose = verbose param.remove_temp_files = remove_temp_files param.parameter = parameter path, file, ext = extract_fname(file_to_denoise) img = nib.load(file_to_denoise) hdr_0 = img.get_header() data = img.get_data() aff = img.get_affine() if min(data.shape) <= 5: printv('One of the image dimensions is <= 5 : reducing the size of the block radius.') block_radius = min(data.shape) - 1 else: block_radius = 5 # default value # Process for manual detecting of background # mask = data[:, :, :] > noise_threshold # data = data[:, :, :] from dipy.denoise.nlmeans import nlmeans if arguments.std is not None: sigma = std_noise # Application of NLM filter to the image printv('Applying Non-local mean filter...') if param.parameter == 'Rician': den = nlmeans(data, sigma=sigma, mask=None, rician=True, block_radius=block_radius) else: den = nlmeans(data, sigma=sigma, mask=None, rician=False, block_radius=block_radius) else: # # Process for manual detecting of background mask = data > noise_threshold sigma = np.std(data[~mask]) # Application of NLM filter to the image printv('Applying Non-local mean filter...') if param.parameter == 'Rician': den = nlmeans(data, sigma=sigma, mask=mask, rician=True, block_radius=block_radius) else: den = nlmeans(data, sigma=sigma, mask=mask, rician=False, block_radius=block_radius) t = time() printv("total time: %s" % (time() - t)) printv("vol size", den.shape) axial_middle = int(data.shape[2] / 2) before = data[:, :, axial_middle].T after = den[:, :, axial_middle].T diff_3d = np.absolute(den.astype('f8') - data.astype('f8')) difference = np.absolute(after.astype('f8') - before.astype('f8')) if arguments.std is None: difference[~mask[:, :, axial_middle].T] = 0 if param.verbose == 2: import matplotlib.pyplot as plt fig, ax = plt.subplots(1, 3) ax[0].imshow(before, cmap='gray', origin='lower') ax[0].set_title('before') ax[1].imshow(after, cmap='gray', origin='lower') ax[1].set_title('after') ax[2].imshow(difference, cmap='gray', origin='lower') ax[2].set_title('difference') for i in range(3): ax[i].set_axis_off() plt.show() # Save files img_denoise = nib.Nifti1Image(den, None, hdr_0) img_diff = nib.Nifti1Image(diff_3d, None, hdr_0) if output_file_name is not None: output_file_name = output_file_name else: output_file_name = file + '_denoised' + ext nib.save(img_denoise, output_file_name) nib.save(img_diff, file + '_difference' + ext) printv('\nDone! To view results, type:', param.verbose) printv('fsleyes ' + file_to_denoise + ' ' + output_file_name + ' & \n', param.verbose, 'info')
def main(argv: Sequence[str]): """ Main function. When this script is run via CLI, the main function is called using main(sys.argv[1:]). :param argv: A list of unparsed arguments, which is passed to ArgumentParser.parse_args() """ for i, arg in enumerate(argv): if arg == '-create-seg' and len(argv) > i+1 and '-1,' in argv[i+1]: raise DeprecationWarning("The use of '-1' for '-create-seg' has been deprecated. Please use " "'-create-seg-mid' instead.") parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.v set_global_loglevel(verbose=verbose) input_filename = arguments.i output_fname = arguments.o img = Image(input_filename) dtype = None if arguments.add is not None: value = arguments.add out = sct_labels.add(img, value) elif arguments.create is not None: labels = arguments.create out = sct_labels.create_labels_empty(img, labels) elif arguments.create_add is not None: labels = arguments.create_add out = sct_labels.create_labels(img, labels) elif arguments.create_seg is not None: labels = arguments.create_seg out = sct_labels.create_labels_along_segmentation(img, labels) elif arguments.create_seg_mid is not None: labels = [(-1, arguments.create_seg_mid)] out = sct_labels.create_labels_along_segmentation(img, labels) elif arguments.cubic_to_point: out = sct_labels.cubic_to_point(img) elif arguments.display: display_voxel(img, verbose) return elif arguments.increment: out = sct_labels.increment_z_inverse(img) elif arguments.disc is not None: ref = Image(arguments.disc) out = sct_labels.labelize_from_discs(img, ref) elif arguments.vert_body is not None: levels = arguments.vert_body if len(levels) == 1 and levels[0] == 0: levels = None # all levels out = sct_labels.label_vertebrae(img, levels) elif arguments.vert_continuous: out = sct_labels.continuous_vertebral_levels(img) dtype = 'float32' elif arguments.MSE is not None: ref = Image(arguments.MSE) mse = sct_labels.compute_mean_squared_error(img, ref) printv(f"Computed MSE: {mse}") return elif arguments.remove_reference is not None: ref = Image(arguments.remove_reference) out = sct_labels.remove_missing_labels(img, ref) elif arguments.remove_sym is not None: # first pass use img as source ref = Image(arguments.remove_reference) out = sct_labels.remove_missing_labels(img, ref) # second pass use previous pass result as reference ref_out = sct_labels.remove_missing_labels(ref, out) ref_out.save(path=ref.absolutepath) elif arguments.remove is not None: labels = arguments.remove out = sct_labels.remove_labels_from_image(img, labels) elif arguments.keep is not None: labels = arguments.keep out = sct_labels.remove_other_labels_from_image(img, labels) elif arguments.create_viewer is not None: msg = "" if arguments.msg is None else f"{arguments.msg}\n" if arguments.ilabel is not None: input_labels_img = Image(arguments.ilabel) out = launch_manual_label_gui(img, input_labels_img, parse_num_list(arguments.create_viewer), msg) else: out = launch_sagittal_viewer(img, parse_num_list(arguments.create_viewer), msg) printv("Generating output files...") out.save(path=output_fname, dtype=dtype) display_viewer_syntax([input_filename, output_fname]) if arguments.qc is not None: generate_qc(fname_in1=input_filename, fname_seg=output_fname, args=argv, path_qc=os.path.abspath(arguments.qc), dataset=arguments.qc_dataset, subject=arguments.qc_subject, process='sct_label_utils')
#!/usr/bin/env python # -*- coding: utf-8 # pytest unit tests for spinalcordtoolbox.qmri import numpy as np import nibabel import pytest from spinalcordtoolbox.qmri import mt from spinalcordtoolbox.image import Image from spinalcordtoolbox.utils import init_sct, set_global_loglevel # Set logger to "DEBUG" init_sct() set_global_loglevel(verbose=2) def make_sct_image(data): """ :return: an Image (3D) in RAS+ (aka SCT LPI) space data: scalar """ affine = np.eye(4) nii = nibabel.nifti1.Nifti1Image(np.array([data, data]), affine) img = Image(nii.get_data(), hdr=nii.header, orientation="LPI", dim=nii.header.get_data_shape()) return img
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv) verbose = arguments.verbose set_global_loglevel(verbose=verbose) # initializations param = Param() param.download = int(arguments.download) param.path_data = arguments.path functions_to_test = arguments.function param.remove_tmp_file = int(arguments.remove_temps) jobs = arguments.jobs param.verbose = verbose start_time = time.time() # get absolute path and add slash at the end param.path_data = os.path.abspath(param.path_data) # check existence of testing data folder if not os.path.isdir(param.path_data) or param.download: downloaddata(param) # display path to data printv('\nPath to testing data: ' + param.path_data, param.verbose) # create temp folder that will have all results path_tmp = os.path.abspath(arguments.execution_folder or tmp_create()) # go in path data (where all scripts will be run) curdir = os.getcwd() os.chdir(param.path_data) functions_parallel = list() functions_serial = list() if functions_to_test: for f in functions_to_test: if f in get_functions_parallelizable(): functions_parallel.append(f) elif f in get_functions_nonparallelizable(): functions_serial.append(f) else: printv( 'Command-line usage error: Function "%s" is not part of the list of testing functions' % f, type='error') jobs = min(jobs, len(functions_parallel)) else: functions_parallel = get_functions_parallelizable() functions_serial = get_functions_nonparallelizable() if arguments.continue_from: first_func = arguments.continue_from if first_func in functions_parallel: functions_serial = [] functions_parallel = functions_parallel[functions_parallel. index(first_func):] elif first_func in functions_serial: functions_serial = functions_serial[functions_serial. index(first_func):] if arguments.check_filesystem and jobs != 1: print("Check filesystem used -> jobs forced to 1") jobs = 1 print("Will run through the following tests:") if functions_serial: print("- sequentially: {}".format(" ".join(functions_serial))) if functions_parallel: print("- in parallel with {} jobs: {}".format( jobs, " ".join(functions_parallel))) list_status = [] for name, functions in ( ("serial", functions_serial), ("parallel", functions_parallel), ): if not functions: continue if any([s for (f, s) in list_status]) and arguments.abort_on_failure: break try: if functions == functions_parallel and jobs != 1: pool = multiprocessing.Pool(processes=jobs) results = list() # loop across functions and run tests for f in functions: func_param = copy.deepcopy(param) func_param.path_output = f res = pool.apply_async(process_function_multiproc, ( f, func_param, )) results.append(res) else: pool = None for idx_function, f in enumerate(functions): print_line('Checking ' + f) if functions == functions_serial or jobs == 1: if arguments.check_filesystem: if os.path.exists(os.path.join(path_tmp, f)): shutil.rmtree(os.path.join(path_tmp, f)) sig_0 = fs_signature(path_tmp) func_param = copy.deepcopy(param) func_param.path_output = f res = process_function(f, func_param) if arguments.check_filesystem: sig_1 = fs_signature(path_tmp) fs_ok(sig_0, sig_1, exclude=(f, )) else: res = results[idx_function].get() list_output, list_status_function = res # manage status if any(list_status_function): if 1 in list_status_function: print_fail() status = (f, 1) else: print_warning() status = (f, 99) for output in list_output: for line in output.splitlines(): print(" %s" % line) else: print_ok() if param.verbose: for output in list_output: for line in output.splitlines(): print(" %s" % line) status = (f, 0) # append status function to global list of status list_status.append(status) if any([s for (f, s) in list_status ]) and arguments.abort_on_failure: break except KeyboardInterrupt: raise finally: if pool: pool.terminate() pool.join() print('status: ' + str([s for (f, s) in list_status])) if any([s for (f, s) in list_status]): print("Failures: {}".format(" ".join( [f for (f, s) in list_status if s]))) # display elapsed time elapsed_time = time.time() - start_time printv('Finished! Elapsed time: ' + str(int(np.round(elapsed_time))) + 's\n') # come back os.chdir(curdir) # remove temp files if param.remove_tmp_file and arguments.execution_folder is None: printv('\nRemove temporary files...', 0) rmtree(path_tmp) e = 0 if any([s for (f, s) in list_status]): e = 1 # print(e) sys.exit(e)
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) fname_bvecs = arguments.bvec # Read bvecs bvecs = read_bvals_bvecs(fname_bvecs, None) bvecs = bvecs[0] # if first dimension is not equal to 3 (x,y,z), transpose bvecs file if not bvecs.shape[0] == 3: bvecs = bvecs.transpose() x, y, z = bvecs[0], bvecs[1], bvecs[2] # Get total number of directions n_dir = len(x) # Get effective number of directions bvecs_eff = [] n_b0 = 0 for i in range(0, n_dir): add_direction = True # check if b=0 if abs(x[i]) < bzero and abs(x[i]) < bzero and abs(x[i]) < bzero: n_b0 += 1 add_direction = False else: # loop across bvecs_eff for j in range(0, len(bvecs_eff)): # if bvalue already present, then do not add to bvecs_eff if bvecs_eff[j] == [x[i], y[i], z[i]]: add_direction = False if add_direction: bvecs_eff.append([x[i], y[i], z[i]]) n_dir_eff = len(bvecs_eff) # Display scatter plot fig = plt.figure(facecolor='white', figsize=(9, 8)) fig.suptitle('Number of b=0: ' + str(n_b0) + ', Number of b!=0: ' + str(n_dir - n_b0) + ', Number of effective directions (without duplicates): ' + str(n_dir_eff)) # plt.ion() # Display three views plot_2dscatter(fig_handle=fig, subplot=221, x=bvecs[0][:], y=bvecs[1][:], xlabel='X', ylabel='Y') plot_2dscatter(fig_handle=fig, subplot=222, x=bvecs[0][:], y=bvecs[2][:], xlabel='X', ylabel='Z') plot_2dscatter(fig_handle=fig, subplot=223, x=bvecs[1][:], y=bvecs[2][:], xlabel='Y', ylabel='Z') # 3D ax = fig.add_subplot(224, projection='3d') # ax.auto_scale_xyz([-1, 1], [-1, 1], [-1, 1]) for i in range(0, n_dir): # x, y, z = bvecs[0], bvecs[1], bvecs[2] # if b=0, do not plot if not(abs(x[i]) < bzero and abs(x[i]) < bzero and abs(x[i]) < bzero): ax.scatter(x[i], y[i], z[i]) ax.set_xlim3d(-1, 1) ax.set_ylim3d(-1, 1) ax.set_zlim3d(-1, 1) plt.title('3D view (use mouse to rotate)') plt.axis('off') # plt.draw() # Save image printv("Saving figure: bvecs.png\n") plt.savefig('bvecs.png') plt.show()
def main(argv=None): parser = get_parser() arguments = parser.parse_args(argv if argv else ['--help']) verbose = arguments.v set_global_loglevel(verbose=verbose) input_filename = arguments.i output_fname = arguments.o img = Image(input_filename) dtype = None if arguments.add is not None: value = arguments.add out = sct_labels.add(img, value) elif arguments.create is not None: labels = arguments.create out = sct_labels.create_labels_empty(img, labels) elif arguments.create_add is not None: labels = arguments.create_add out = sct_labels.create_labels(img, labels) elif arguments.create_seg is not None: labels = arguments.create_seg out = sct_labels.create_labels_along_segmentation(img, labels) elif arguments.cubic_to_point: out = sct_labels.cubic_to_point(img) elif arguments.display: display_voxel(img, verbose) return elif arguments.increment: out = sct_labels.increment_z_inverse(img) elif arguments.disc is not None: ref = Image(arguments.disc) out = sct_labels.labelize_from_discs(img, ref) elif arguments.vert_body is not None: levels = arguments.vert_body if len(levels) == 1 and levels[0] == 0: levels = None # all levels out = sct_labels.label_vertebrae(img, levels) elif arguments.vert_continuous: out = sct_labels.continuous_vertebral_levels(img) dtype = 'float32' elif arguments.MSE is not None: ref = Image(arguments.MSE) mse = sct_labels.compute_mean_squared_error(img, ref) printv(f"Computed MSE: {mse}") return elif arguments.remove_reference is not None: ref = Image(arguments.remove_reference) out = sct_labels.remove_missing_labels(img, ref) elif arguments.remove_sym is not None: # first pass use img as source ref = Image(arguments.remove_reference) out = sct_labels.remove_missing_labels(img, ref) # second pass use previous pass result as reference ref_out = sct_labels.remove_missing_labels(ref, out) ref_out.save(path=ref.absolutepath) elif arguments.remove is not None: labels = arguments.remove out = sct_labels.remove_labels_from_image(img, labels) elif arguments.keep is not None: labels = arguments.keep out = sct_labels.remove_other_labels_from_image(img, labels) elif arguments.create_viewer is not None: msg = "" if arguments.msg is None else f"{arguments.msg}\n" if arguments.ilabel is not None: input_labels_img = Image(arguments.ilabel) out = launch_manual_label_gui( img, input_labels_img, parse_num_list(arguments.create_viewer), msg) else: out = launch_sagittal_viewer( img, parse_num_list(arguments.create_viewer), msg) printv("Generating output files...") out.save(path=output_fname, dtype=dtype) display_viewer_syntax([input_filename, output_fname]) if arguments.qc is not None: generate_qc(fname_in1=input_filename, fname_seg=output_fname, args=argv, path_qc=os.path.abspath(arguments.qc), dataset=arguments.qc_dataset, subject=arguments.qc_subject, process='sct_label_utils')