def main(): parser = _build_arg_parser() args = parser.parse_args() # Checking args assert_inputs_exist(parser, args.in_image, args.ref) assert_outputs_exist(parser, args, args.out_image) if args.enforce_dimensions and not args.ref: parser.error("Cannot enforce dimensions without a reference image") if args.verbose: logging.basicConfig(level=logging.DEBUG) logging.debug('Loading Raw data from %s', args.in_image) img = nib.load(args.in_image) # Resampling volume resampled_img = resample_volume(img, ref=args.ref, res=args.resolution, iso_min=args.iso_min, interp=args.interp, enforce_dimensions=args.enforce_dimensions) # Saving results logging.debug('Saving resampled data to %s', args.out_image) nib.save(resampled_img, args.out_image)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_bundle, optional=args.reference) assert_outputs_exist(parser, args, args.out_img) max_ = np.iinfo(np.int16).max if args.binary is not None and (args.binary <= 0 or args.binary > max_): parser.error( 'The value of --binary ({}) ' 'must be greater than 0 and smaller or equal to {}'.format( args.binary, max_)) sft = load_tractogram_with_reference(parser, args, args.in_bundle) sft.to_vox() sft.to_corner() streamlines = sft.streamlines transformation, dimensions, _, _ = sft.space_attributes streamline_count = compute_tract_counts_map(streamlines, dimensions) if args.binary is not None: streamline_count[streamline_count > 0] = args.binary nib.save( nib.Nifti1Image(streamline_count.astype(np.int16), transformation), args.out_img)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, args.out_tractogram) if not args.out_tractogram.endswith('.trk'): parser.error('Output file needs to end with .trk.') if len(args.color) == 7: args.color = '0x' + args.color.lstrip('#') if len(args.color) == 8: color_int = int(args.color, 0) red = color_int >> 16 green = (color_int & 0x00FF00) >> 8 blue = color_int & 0x0000FF else: parser.error('Hexadecimal RGB color should be formatted as "#RRGGBB"' ' or 0xRRGGBB.') sft = load_tractogram_with_reference(parser, args, args.in_tractogram) sft.data_per_point["color"] = [ np.tile([red, green, blue], (len(i), 1)) for i in sft.streamlines ] sft = StatefulTractogram.from_sft(sft.streamlines, sft, data_per_point=sft.data_per_point) save_tractogram(sft, args.out_tractogram)
def main(): parser = build_args_parser() args = parser.parse_args() if args.verbose: logging.basicConfig(level=logging.INFO) img_inputs = [s for s in args.inputs if s != 'ones'] if len(img_inputs): assert_inputs_exist(parser, img_inputs) assert_outputs_exist(parser, args, [args.output]) # Load all input masks. masks = [load_data(f) for f in args.inputs] # Apply the requested operation to each input file. logging.info('Performing operation \'{}\'.'.format(args.operation)) mask = reduce(OPERATIONS[args.operation], masks) if args.threshold: mask = (mask > args.threshold).astype(np.uint8) affine = next( nibabel.load(f).affine for f in args.inputs if os.path.isfile(f)) new_img = nibabel.Nifti1Image(mask, affine) nibabel.save(new_img, args.output)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.in_fodfs, args.in_fa, args.in_md]) assert_outputs_exist(parser, args, [], [args.max_value_output, args.mask_output]) if args.verbose: logging.basicConfig(level=logging.DEBUG) # Load input image img_fODFs = nib.load(args.in_fodfs) fodf = img_fODFs.get_fdata(dtype=np.float32) affine = img_fODFs.affine zoom = img_fODFs.header.get_zooms()[:3] img_fa = nib.load(args.in_fa) fa = img_fa.get_fdata(dtype=np.float32) img_md = nib.load(args.in_md) md = img_md.get_fdata(dtype=np.float32) value, mask = get_ventricles_max_fodf(fodf, fa, md, zoom, args) if args.mask_output: img = nib.Nifti1Image(np.array(mask, 'float32'), affine) nib.save(img, args.mask_output) if args.max_value_output: text_file = open(args.max_value_output, "w") text_file.write(str(value)) text_file.close() else: print("Maximal value in ventricles: {}".format(value))
def main(): parser = _build_args_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, args.out_tractogram) tractogram_file = load(args.in_tractogram) streamlines = list(tractogram_file.streamlines) data_per_point = tractogram_file.tractogram.data_per_point data_per_streamline = tractogram_file.tractogram.data_per_streamline new_streamlines, new_per_point, new_per_streamline = get_subset_streamlines( streamlines, data_per_point, data_per_streamline, args.max_num_streamlines, args.seed) new_tractogram = Tractogram(new_streamlines, data_per_point=new_per_point, data_per_streamline=new_per_streamline, affine_to_rasmm=np.eye(4)) save(new_tractogram, args.out_tractogram, header=tractogram_file.header)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist( parser, [args.map_include, args.map_exclude, args.additional_mask]) assert_outputs_exist(parser, args, [args.map_include_corr, args.map_exclude_corr]) map_inc = nib.load(args.map_include) map_inc_data = map_inc.get_fdata(dtype=np.float32) map_exc = nib.load(args.map_exclude) map_exc_data = map_exc.get_fdata(dtype=np.float32) additional_mask = nib.load(args.additional_mask) additional_mask_data = get_data_as_mask(additional_mask) map_inc_data[additional_mask_data > 0] = 0 map_exc_data[additional_mask_data > 0] = 0 # TODO Remove header or add optional argument name nib.save( nib.Nifti1Image(map_inc_data.astype('float32'), map_inc.affine, map_inc.header), args.map_include_corr) nib.save( nib.Nifti1Image(map_exc_data.astype('float32'), map_exc.affine, map_exc.header), args.map_exclude_corr)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.in_metric, args.in_mask]) assert_outputs_exist(parser, args, args.out_png) # Load metric image metric_img = nib.load(args.in_metric) metric_img_data = metric_img.get_fdata(dtype=np.float32) # Load mask image mask_img = nib.load(args.in_mask) mask_img_data = get_data_as_mask(mask_img) # Select value from mask curr_data = metric_img_data[np.where(mask_img_data > 0)] # Display figure fig, ax = plt.subplots() n, bins, patches = ax.hist(curr_data, bins=args.n_bins, color=args.colors, alpha=0.5, rwidth=0.85) plt.xlabel(args.x_label) plt.title(args.title) if args.show_only: plt.show() else: plt.savefig(args.out_png, dpi=300, bbox_inches='tight')
def main(): parser = _build_arg_parser() args = parser.parse_args() if args.verbose: logging.basicConfig(level=logging.INFO) # Checking args assert_outputs_exist(parser, args, args.out_sh) assert_inputs_exist(parser, args.in_sh) # Prepare data sh_img = nib.load(args.in_sh) data = sh_img.get_fdata(dtype=np.float32) sh_order, full_basis = get_sh_order_and_fullness(data.shape[-1]) logging.info('Executing local asymmetric filtering.') filtered_sh = local_asym_filtering( data, sh_order=sh_order, sh_basis=args.sh_basis, in_full_basis=full_basis, out_full_basis=not(args.out_sym), sphere_str=args.sphere, dot_sharpness=args.sharpness, sigma=args.sigma) logging.info('Saving filtered SH to file {0}.'.format(args.out_sh)) nib.save(nib.Nifti1Image(filtered_sh, sh_img.affine), args.out_sh)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.tractogram]) assert_outputs_exist(parser, args, [], [args.save]) tracts_format = detect_format(args.tractogram) if tracts_format is not TrkFile: raise ValueError("Invalid input streamline file format " + "(must be trk): {0}".format(args.tractogram_filename)) # Load files and data. TRKs can have 'same' as reference tractogram = load_tractogram(args.tractogram, 'same') # Streamlines are saved in RASMM but seeds are saved in VOX # This might produce weird behavior with non-iso tractogram.to_vox() streamlines = tractogram.streamlines if 'seeds' not in tractogram.data_per_streamline: parser.error('Tractogram does not contain seeds') seeds = tractogram.data_per_streamline['seeds'] # Make display objects streamlines_actor = actor.line(streamlines) points = actor.dots(seeds, color=(1., 1., 1.)) # Add display objects to canvas r = window.Renderer() r.add(streamlines_actor) r.add(points) # Show and record if needed if args.save is not None: window.record(r, out_path=args.save, size=(1000, 1000)) window.show(r)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, args.out_tractogram) check_tracts_same_format(parser, args.in_tractogram, args.out_tractogram) if args.error_rate < 0.001 or args.error_rate > 1: logging.warning( 'You are using an error rate of {}.\n' 'We recommend setting it between 0.001 and 1.\n' '0.001 will do almost nothing to the streamlines\n' 'while 1 will highly compress/linearize the streamlines'.format( args.error_rate)) in_tractogram = nib.streamlines.load(args.in_tractogram, lazy_load=True) compressed_streamlines = compress_streamlines_wrapper( in_tractogram, args.error_rate) out_tractogram = LazyTractogram(compressed_streamlines, affine_to_rasmm=np.eye(4)) nib.streamlines.save(out_tractogram, args.out_tractogram, header=in_tractogram.header)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.in_dwi, args.in_bval, args.in_bvec]) assert_outputs_exist(parser, args, args.out_sh) vol = nib.load(args.in_dwi) dwi = vol.get_fdata(dtype=np.float32) bvals, bvecs = read_bvals_bvecs(args.in_bval, args.in_bvec) gtab = gradient_table(args.in_bval, args.in_bvec, b0_threshold=bvals.min()) mask = None if args.mask: mask = get_data_as_mask(nib.load(args.mask), dtype=bool) sh = compute_sh_coefficients(dwi, gtab, args.sh_order, args.sh_basis, args.smooth, use_attenuation=args.use_attenuation, mask=mask) nib.save(nib.Nifti1Image(sh.astype(np.float32), vol.affine), args.out_sh)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_surface, args.vts_mask) assert_outputs_exist(parser, args, args.out_surface) # Check smoothing parameters if args.nb_steps < 1: parser.error("Number of steps should be strictly positive") if args.step_size <= 0.0: parser.error("Step size should be strictly positive") if args.verbose: logging.basicConfig(level=logging.DEBUG) # Step size (zero for masked vertices) if args.vts_mask: mask = np.load(args.vts_mask) step_size_per_vts = args.step_size * mask.astype(np.float) else: step_size_per_vts = args.step_size mesh = load_mesh_from_file(args.in_surface) # Laplacian smoothing vts = mesh.laplacian_smooth(nb_iter=args.nb_steps, diffusion_step=step_size_per_vts, backward_step=True) mesh.set_vertices(vts) # Save Mesh Surface mesh.save(args.out_surface)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_bundles) output_streamlines_filename = '{}streamlines.trk'.format( args.output_prefix) output_voxels_filename = '{}voxels.nii.gz'.format(args.output_prefix) assert_outputs_exist(parser, args, [output_voxels_filename, output_streamlines_filename]) if not 0 <= args.ratio_voxels <= 1 or not 0 <= args.ratio_streamlines <= 1: parser.error('Ratios must be between 0 and 1.') fusion_streamlines = [] if args.reference: reference_file = args.reference else: reference_file = args.in_bundles[0] sft_list = [] for name in args.in_bundles: tmp_sft = load_tractogram_with_reference(parser, args, name) tmp_sft.to_vox() tmp_sft.to_corner() if not is_header_compatible(reference_file, tmp_sft): raise ValueError('Headers are not compatible.') sft_list.append(tmp_sft) fusion_streamlines.append(tmp_sft.streamlines) fusion_streamlines, _ = union_robust(fusion_streamlines) transformation, dimensions, _, _ = get_reference_info(reference_file) volume = np.zeros(dimensions) streamlines_vote = dok_matrix( (len(fusion_streamlines), len(args.in_bundles))) for i in range(len(args.in_bundles)): sft = sft_list[i] binary = compute_tract_counts_map(sft.streamlines, dimensions) volume[binary > 0] += 1 if args.same_tractogram: _, indices = intersection_robust( [fusion_streamlines, sft.streamlines]) streamlines_vote[list(indices), [i]] += 1 if args.same_tractogram: real_indices = [] ratio_value = int(args.ratio_streamlines * len(args.in_bundles)) real_indices = np.where( np.sum(streamlines_vote, axis=1) >= ratio_value)[0] new_sft = StatefulTractogram.from_sft(fusion_streamlines[real_indices], sft_list[0]) save_tractogram(new_sft, output_streamlines_filename) volume[volume < int(args.ratio_voxels * len(args.in_bundles))] = 0 volume[volume > 0] = 1 nib.save(nib.Nifti1Image(volume.astype(np.uint8), transformation), output_voxels_filename)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.input_path, args.input_bbox) assert_outputs_exist(parser, args, args.output_path, args.output_bbox) img = nib.load(args.input_path) if args.input_bbox: with open(args.input_bbox, 'rb') as bbox_file: wbbox = pickle.load(bbox_file) if not args.ignore_voxel_size: voxel_size = img.header.get_zooms()[0:3] if not np.allclose(voxel_size, wbbox.voxel_size[0:3]): raise IOError("Bounding box and data voxel sizes are not " "compatible. Use option --ignore_voxel_size " "to ignore this test.") else: wbbox = compute_nifti_bounding_box(img) if args.output_bbox: with open(args.output_bbox, 'wb') as bbox_file: pickle.dump(wbbox, bbox_file) out_nifti_file = crop_nifti(img, wbbox) nib.save(out_nifti_file, args.output_path)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist( parser, [args.map_include, args.map_exclude, args.additional_mask]) assert_outputs_exist(parser, args, [args.map_include_corr, args.map_exclude_corr]) map_inc = nib.load(args.map_include) map_inc_data = map_inc.get_data() map_exc = nib.load(args.map_exclude) map_exc_data = map_exc.get_data() additional_mask = nib.load(args.additional_mask) additional_mask_data = additional_mask.get_data() map_inc_data[additional_mask_data > 0] = 0 map_exc_data[additional_mask_data > 0] = 0 nib.save( nib.Nifti1Image(map_inc_data.astype('float32'), map_inc.affine, map_inc.header), args.map_include_corr) nib.save( nib.Nifti1Image(map_exc_data.astype('float32'), map_exc.affine, map_exc.header), args.map_exclude_corr)
def main(): parser = _build_args_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_image) assert_outputs_exist(parser, args, args.out_image) original_im = nib.load(args.in_image) if original_im.ndim == 4: if "float" in original_im.header.get_data_shape(): scale = True else: scale = False converted_im = decfa(original_im, scale=scale) nib.save(converted_im, args.out_image) elif original_im.ndim == 3: converted_im_float = decfa_to_float(original_im) converted_data = converted_im_float.get_fdata() converted_data_int = converted_data.astype("uint8") converted_im = nib.Nifti1Image(converted_data_int, converted_im_float.affine) nib.save(converted_im, args.out_image)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, [], optional=args.out_centroids) assert_output_dirs_exist_and_empty(parser, args, args.out_clusters_dir, create_dir=True) sft = load_tractogram_with_reference(parser, args, args.in_tractogram) streamlines = sft.streamlines thresholds = [40, 30, 20, args.dist_thresh] clusters = qbx_and_merge(streamlines, thresholds, nb_pts=args.nb_points, verbose=False) for i, cluster in enumerate(clusters): if len(cluster.indices) > 1: cluster_streamlines = itemgetter(*cluster.indices)(streamlines) else: cluster_streamlines = streamlines[cluster.indices] new_sft = StatefulTractogram.from_sft(cluster_streamlines, sft) save_tractogram( new_sft, os.path.join(args.out_clusters_dir, 'cluster_{}.trk'.format(i))) if args.out_centroids: new_sft = StatefulTractogram.from_sft(clusters.centroids, sft) save_tractogram(new_sft, args.out_centroids)
def main(): parser = _build_arg_parser() args = parser.parse_args() if args.verbose: logging.basicConfig(level=logging.INFO) assert_inputs_exist(parser, [args.dwi, args.bvals, args.bvecs]) assert_outputs_exist(parser, args, [args.output_dwi, args.output_bvals, args.output_bvecs]) bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs) # Find the volume indices that correspond to the shells to extract. tol = args.tolerance img = nib.load(args.dwi) outputs = extract_dwi_shell(img, bvals, bvecs, args.bvals_to_extract, tol, args.block_size) indices, shell_data, new_bvals, new_bvecs = outputs logging.info("Selected indices: {}".format(indices)) np.savetxt(args.output_bvals, new_bvals, '%d') np.savetxt(args.output_bvecs, new_bvecs.T, '%0.15f') nib.save(nib.Nifti1Image(shell_data, img.affine, img.header), args.output_dwi)
def main(): parser = _build_arg_parser() args = parser.parse_args() if args.verbose: logging.basicConfig(level=logging.INFO) assert_inputs_exist(parser, args.in_sh, args.mask) assert_outputs_exist(parser, args, args.out_bingham) sh_im = nib.load(args.in_sh) data = sh_im.get_fdata() mask = get_data_as_mask(nib.load(args.mask), dtype=bool)\ if args.mask else None # validate number of processes nbr_processes = validate_nbr_processes(parser, args) logging.info('Number of processes: {}'.format(nbr_processes)) t0 = time.perf_counter() logging.info('Fitting Bingham functions.') bingham = bingham_fit_sh(data, args.max_lobes, abs_th=args.at, rel_th=args.rt, min_sep_angle=args.min_sep_angle, max_fit_angle=args.max_fit_angle, mask=mask, nbr_processes=nbr_processes) t1 = time.perf_counter() logging.info('Fitting done in (s): {0}'.format(t1 - t0)) nib.save(nib.Nifti1Image(bingham, sh_im.affine), args.out_bingham)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.input_sh]) assert_outputs_exist(parser, args, [args.output_name]) input_basis = args.sh_basis output_basis = 'descoteaux07' if input_basis == 'tournier07' else 'tournier07' sph_harm_basis_ori = sph_harm_lookup.get(input_basis) sph_harm_basis_des = sph_harm_lookup.get(output_basis) sphere = get_sphere('repulsion724').subdivide(1) img = nib.load(args.input_sh) data = img.get_data() sh_order = find_order_from_nb_coeff(data) b_ori, m_ori, n_ori = sph_harm_basis_ori(sh_order, sphere.theta, sphere.phi) b_des, m_des, n_des = sph_harm_basis_des(sh_order, sphere.theta, sphere.phi) l_des = -n_des * (n_des + 1) inv_b_des = smooth_pinv(b_des, 0 * l_des) indices = np.argwhere(np.any(data, axis=3)) for i, ind in enumerate(indices): ind = tuple(ind) sf_1 = np.dot(data[ind], b_ori.T) data[ind] = np.dot(sf_1, inv_b_des.T) img = nib.Nifti1Image(data, img.affine, img.header) nib.save(nib.Nifti1Image(data, img.affine, img.header), args.output_name)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.moving_tractogram, args.static_tractogram]) if args.only_rigid: matrix_filename = os.path.splitext(args.out_name)[0] + '_rigid.txt' else: matrix_filename = os.path.splitext(args.out_name)[0] + '_affine.txt' assert_outputs_exist(parser, args, matrix_filename, args.out_name) sft_moving = load_tractogram_with_reference(parser, args, args.moving_tractogram, arg_name='moving_tractogram') sft_static = load_tractogram_with_reference(parser, args, args.static_tractogram, arg_name='static_tractogram') if args.only_rigid: transformation_type = 'rigid' else: transformation_type = 'affine' ret = whole_brain_slr(sft_moving.streamlines, sft_static.streamlines, x0=transformation_type, maxiter=150, verbose=args.verbose) _, transfo, _, _ = ret np.savetxt(matrix_filename, transfo)
def main(): parser = _build_args_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.tractogram]) assert_outputs_exist(parser, args, [], [args.save]) tracts_format = detect_format(args.tractogram) if tracts_format is not TrkFile: raise ValueError("Invalid input streamline file format " + "(must be trk): {0}".format(args.tractogram_filename)) # Load files and data trk = TrkFile.load(args.tractogram) tractogram = trk.tractogram streamlines = tractogram.streamlines if 'seeds' not in tractogram.data_per_streamline: parser.error('Tractogram does not contain seeds') seeds = tractogram.data_per_streamline['seeds'] # Make display objects streamlines_actor = actor.line(streamlines) points = actor.dots(seeds, color=(1., 1., 1.)) # Add display objects to canvas r = window.Renderer() r.add(streamlines_actor) r.add(points) # Show and record if needed if args.save is not None: window.record(r, out_path=args.save, size=(1000, 1000)) window.show(r)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_json) assert_outputs_exist(parser, args, args.out_json) out_dict = {} for in_file in args.in_json: with open(in_file, 'r') as json_file: in_dict = json.load(json_file) if args.remove_parent_key: in_dict = list(in_dict.values())[0] if args.keep_separate: out_dict[os.path.splitext(in_file)[0]] = in_dict else: out_dict = _merge_dict(out_dict, in_dict, no_list=args.no_list, recursive=args.recursive) if args.average_last_layer: out_dict = _average_dict(out_dict) with open(args.out_json, 'w') as outfile: if args.add_parent_key: out_dict = {args.add_parent_key: out_dict} json.dump(out_dict, outfile, indent=args.indent, sort_keys=args.sort_keys)
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, args.out_tractogram) log_level = logging.WARNING if args.verbose: log_level = logging.DEBUG logging.basicConfig(level=log_level) sft = load_tractogram_with_reference(parser, args, args.in_tractogram) smoothed_streamlines = [] for streamline in sft.streamlines: if args.gaussian: tmp_streamlines = smooth_line_gaussian(streamline, args.gaussian) else: tmp_streamlines = smooth_line_spline(streamline, args.spline[0], args.spline[1]) if args.error_rate: smoothed_streamlines.append( compress_streamlines(tmp_streamlines, args.error_rate)) smoothed_sft = StatefulTractogram.from_sft( smoothed_streamlines, sft, data_per_streamline=sft.data_per_streamline) save_tractogram(smoothed_sft, args.out_tractogram)
def _parse_args(parser): args = parser.parse_args() inputs = [] output = [] inputs.append(args.in_fodf) if args.output: output.append(args.output) else: if args.silent: parser.error('Silent mode is enabled but no output is specified.' 'Specify an output with --output to use silent mode.') if args.mask: inputs.append(args.mask) if args.background: inputs.append(args.background) if args.peaks: if args.full_basis: # FURY doesn't support asymmetric peaks visualization warnings.warn( 'Asymmetric peaks visualization is not supported ' 'by FURY. Peaks shown as symmetric peaks.', UserWarning) inputs.append(args.peaks) if args.peaks_values: inputs.append(args.peaks_values) else: if args.peaks_values: parser.error('Peaks values image supplied without peaks. Specify ' 'a peaks image with --peaks to use this feature.') assert_inputs_exist(parser, inputs) assert_outputs_exist(parser, args, output) return args
def main(): """Parse arguments, generate hdf5 dataset and save it on disk.""" p = _parse_args() args = p.parse_args() # Initialize logger logging.basicConfig(level=str(args.logging).upper()) # Silencing SFT's logger if our logging is in DEBUG mode, because it # typically produces a lot of outputs! set_sft_logger_level('WARNING') # Verify that dwi_ml_ready folder is found if not Path(args.dwi_ml_ready_folder).is_dir(): raise ValueError('The dwi_ml_ready folder was not found: {}'.format( args.dwi_ml_ready_folder)) assert_inputs_exist( p, [args.config_file], [args.training_subjs, args.validation_subjs, args.testing_subjs]) # check hdf extension _, ext = os.path.splitext(args.out_hdf5_file) if ext == '': args.out_hdf5_file += '.hdf5' elif ext != '.hdf5': raise p.error("The hdf5 file's extension should be .hdf5, but " "received {}".format(ext)) assert_outputs_exist(p, args, args.out_hdf5_file) # Prepare creator and load config file. creator = prepare_hdf5_creator(args) # Create dataset from config and save with Timer("\nCreating database...", newline=True, color='green'): creator.create_database()
def main(): parser = _build_arg_parser() args = parser.parse_args() assert_inputs_exist(parser, [args.input, args.fa, args.md]) assert_outputs_exist(parser, args, [], [args.max_value_output, args.mask_output]) if args.verbose: logging.basicConfig(level=logging.DEBUG) # Load input image fodf, affine, zoom = load(args.input) fa, _, _ = load(args.fa) md, _, _ = load(args.md) value, mask = get_ventricles_max_fodf(fodf, fa, md, zoom, args) if args.mask_output: save(mask, affine, args.mask_output) if args.max_value_output: text_file = open(args.max_value_output, "w") text_file.write(str(value)) text_file.close() else: print("Maximal value in ventricles: {}".format(value))
def _parse_args(parser): args = parser.parse_args() inputs = [] output = [] inputs.append(args.in_fodf) if args.output: output.append(args.output) else: if args.silent: parser.error('Silent mode is enabled but no output is specified.' 'Specify an output with --output to use silent mode.') if args.mask: inputs.append(args.mask) if args.background: inputs.append(args.background) if args.peaks: inputs.append(args.peaks) if args.peaks_values: inputs.append(args.peaks_values) else: if args.peaks_values: parser.error('Peaks values image supplied without peaks. Specify ' 'a peaks image with --peaks to use this feature.') assert_inputs_exist(parser, inputs) assert_outputs_exist(parser, args, output) return args
def main(): parser = _build_args_parser() args = parser.parse_args() assert_inputs_exist(parser, args.in_tractogram) assert_outputs_exist(parser, args, args.out_tractogram) if args.verbose: logging.basicConfig(level=logging.DEBUG) sft = load_tractogram_with_reference(parser, args, args.in_tractogram) new_streamlines, new_per_point, new_per_streamline = filter_streamlines_by_length( sft, args.minL, args.maxL) new_sft = StatefulTractogram(new_streamlines, sft, Space.RASMM, data_per_streamline=new_per_streamline, data_per_point=new_per_point) if not new_streamlines: if args.no_empty: logging.debug("The file {} won't be written " "(0 streamline).".format(args.out_tractogram)) return logging.debug('The file {} contains 0 streamline'.format( args.out_tractogram)) save_tractogram(new_sft, args.out_tractogram)