def _parse_args(parser):
args = parser.parse_args()
inputs = []
output = []
inputs.append(args.in_bingham)
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.')
assert_inputs_exist(parser, inputs)
assert_outputs_exist(parser, args, output)
return args
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.tracts, args.ref_anat])
assert_outputs_exists(parser, args, [args.out])
check_tracts_support(parser, args.tracts, False)
check_tracts_same_format(parser, args.tracts, args.out)
# Deactivated for now.
# Tested implicitely with the 2 previous tracts checks.
# if not tc.is_supported(args.out):
# parser.error('Format of "{0}" not supported.'.format(args.out))
filter_points(args.tracts, args.ref_anat, args.out,
args.nifti_compliant_gen, args.for_nifti_compliant)
def main():
parser = _build_args_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.tracts, args.ref_anat])
assert_outputs_exists(parser, args, [args.out])
check_tracts_support(parser, args.tracts, False)
if not tc.is_supported(args.out):
parser.error('Format of "{0}" not supported.'.format(args.out))
if not args.x and not args.y and not args.z:
parser.error('No flipping axis specified.')
flip_streamlines(args.tracts, args.ref_anat, args.out, args.x, args.y,
args.z, args.mode)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.tractogram_filename])
assert_outputs_exist(parser, args, [args.seed_density_filename])
tracts_format = detect_format(args.tractogram_filename)
if tracts_format is not TrkFile:
raise ValueError("Invalid input streamline file format " +
"(must be trk): {0}".format(args.tractogram_filename))
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_))
# Load files and data. TRKs can have 'same' as reference
# Can handle streamlines outside of bbox
sft = load_tractogram(args.tractogram_filename,
'same',
bbox_valid_check=False)
# Streamlines are saved in RASMM but seeds are saved in VOX
# This might produce weird behavior with non-iso
sft.to_vox()
sft.to_corner()
if 'seeds' in sft.data_per_streamline:
seeds = sft.data_per_streamline['seeds']
else:
parser.error('Tractogram does not contain seeds')
# Create seed density map
_, shape, _, _ = sft.space_attributes
seed_density = np.zeros(shape, dtype=np.int32)
for seed in seeds:
# Set value at mask, either binary or increment
seed_voxel = np.round(seed).astype(int)
if args.binary is not None:
seed_density[tuple(seed_voxel)] = args.binary
else:
seed_density[tuple(seed_voxel)] += 1
# Save seed density map
dm_img = Nifti1Image(seed_density.astype(np.int32), sft.affine)
dm_img.to_filename(args.seed_density_filename)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.in_bundle] + args.metrics)
assert_output_dirs_exist_and_empty(parser,
args,
args.output_folder,
create_dir=True)
assert_same_resolution(args.metrics)
sft = load_tractogram_with_reference(parser, args, args.in_bundle)
sft.to_vox()
sft.to_corner()
if len(sft.streamlines) == 0:
logging.warning('Empty bundle file {}. Skipping'.format(args.bundle))
return
mins, maxs, indices = _process_streamlines(sft.streamlines)
metrics = [nib.load(metric) for metric in args.metrics]
for metric in metrics:
data = metric.get_data()
endpoint_metric_map = np.zeros(metric.shape)
count = np.zeros(metric.shape)
for cur_min, cur_max, cur_ind, orig_s in zip(mins, maxs, indices,
sft.streamlines):
streamline_mean = _compute_streamline_mean(cur_ind, cur_min,
cur_max, data)
xyz = orig_s[0, :].astype(int)
endpoint_metric_map[xyz[0], xyz[1], xyz[2]] += streamline_mean
count[xyz[0], xyz[1], xyz[2]] += 1
xyz = orig_s[-1, :].astype(int)
endpoint_metric_map[xyz[0], xyz[1], xyz[2]] += streamline_mean
count[xyz[0], xyz[1], xyz[2]] += 1
endpoint_metric_map[count != 0] /= count[count != 0]
metric_fname, ext = split_name_with_nii(
os.path.basename(metric.get_filename()))
nib.save(
nib.Nifti1Image(endpoint_metric_map, metric.affine, metric.header),
os.path.join(args.output_folder,
'{}_endpoints_metric{}'.format(metric_fname, ext)))
def main():
parser = _build_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
assert_inputs_exist(parser, [args.in_dwi, args.in_bval, args.in_bvec])
assert_outputs_exist(parser, args, args.frf_file)
if len(args.roi_radii) == 1:
roi_radii = args.roi_radii[0]
elif len(args.roi_radii) == 3:
roi_radii = args.roi_radii
else:
parser.error('Wrong size for --roi_radii, can only be a scalar' +
'or an array of size (3,)')
vol = nib.load(args.in_dwi)
data = vol.get_fdata(dtype=np.float32)
bvals, bvecs = read_bvals_bvecs(args.in_bval, args.in_bvec)
mask = None
if args.mask:
mask = get_data_as_mask(nib.load(args.mask), dtype=bool)
mask_wm = None
if args.mask_wm:
mask_wm = get_data_as_mask(nib.load(args.mask_wm), dtype=bool)
full_response = compute_ssst_frf(
data,
bvals,
bvecs,
mask=mask,
mask_wm=mask_wm,
fa_thresh=args.fa_thresh,
min_fa_thresh=args.min_fa_thresh,
min_nvox=args.min_nvox,
roi_radii=roi_radii,
roi_center=args.roi_center,
force_b0_threshold=args.force_b0_threshold)
np.savetxt(args.frf_file, full_response)
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.from_sft(
new_streamlines,
sft,
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)
if args.display_counts:
tc_bf = len(sft.streamlines)
tc_af = len(new_streamlines)
print(
json.dumps(
{
'tract_count_before_filtering': int(tc_bf),
'tract_count_after_filtering': int(tc_af)
},
indent=args.indent))
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_matrix,
[args.labels_list, args.in_ordering])
assert_output_dirs_exist_and_empty(parser, args, [], args.out_dir)
if args.out_dir is None:
args.out_dir = './'
out_filenames = []
for filename in args.in_matrix:
basename, _ = os.path.splitext(filename)
basename = os.path.basename(basename)
out_filenames.append('{}/{}{}.npy'.format(args.out_dir,
args.out_prefix, basename))
assert_outputs_exist(parser, args, out_filenames)
with open(args.in_ordering, 'r') as my_file:
lines = my_file.readlines()
ordering = [[int(val) for val in lines[0].split()],
[int(val) for val in lines[1].split()]]
for filename in args.in_matrix:
basename, _ = os.path.splitext(filename)
basename = os.path.basename(basename)
matrix = load_matrix_in_any_format(filename)
if args.labels_list:
labels_list = np.loadtxt(args.labels_list, dtype=np.int16).tolist()
indices_1, indices_2 = [], []
for j in ordering[0]:
indices_1.append(labels_list.index(j))
for j in ordering[1]:
indices_2.append(labels_list.index(j))
else:
indices_1 = ordering[0]
indices_2 = ordering[1]
if (np.array(indices_1) > matrix.shape[0]).any() \
or (indices_2 > np.array(matrix.shape[1])).any():
raise ValueError('Indices from config higher than matrix size, '
'maybe you need a labels list?')
tmp_matrix = matrix[tuple(indices_1), :]
tmp_matrix = tmp_matrix[:, tuple(indices_2)]
save_matrix_in_any_format(
'{}/{}{}.npy'.format(args.out_dir, args.out_prefix, basename),
tmp_matrix)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.input)
assert_outputs_exist(parser, args, args.output, args.logfile)
logging.basicConfig()
log = logging.getLogger(__name__)
if args.verbose:
log.setLevel(level=logging.INFO)
else:
log.setLevel(level=logging.WARNING)
if args.logfile is not None:
log.addHandler(logging.FileHandler(args.logfile, mode='w'))
vol = nb.load(args.input)
data = vol.get_fdata(dtype=np.float32)
if args.mask is None:
mask = np.zeros(data.shape, dtype=np.bool)
if data.ndim == 4:
mask[np.sum(data, axis=-1) > 0] = 1
else:
mask[data > 0] = 1
else:
mask = get_data_as_mask(nb.load(args.mask), dtype=np.bool)
sigma = args.sigma
if sigma is not None:
log.info('User supplied noise standard deviation is {}'.format(sigma))
# Broadcast the single value to a whole 3D volume for nlmeans
sigma = np.ones(data.shape[:3]) * sigma
else:
log.info('Estimating noise')
sigma = _get_basic_sigma(vol.get_fdata(dtype=np.float32), log)
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=DeprecationWarning)
data_denoised = nlmeans(data,
sigma,
mask=mask,
rician=args.N > 0,
num_threads=args.nbr_processes)
nb.save(nb.Nifti1Image(data_denoised, vol.affine, vol.header), args.output)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.in_bundle, args.in_label_map,
args.in_distance_map] + args.in_metrics)
assert_outputs_exist(parser, args, '', args.out_json)
# Load everything
sft = load_tractogram_with_reference(parser, args, args.in_bundle)
sft.to_vox()
sft.to_corner()
bundle_name, _ = os.path.splitext(os.path.basename(args.in_bundle))
if len(sft) == 0:
stats = {bundle_name: None}
print(json.dumps(stats, indent=args.indent, sort_keys=args.sort_keys))
return
assert_same_resolution(args.in_metrics)
metrics = [nib.load(metric) for metric in args.in_metrics]
label_file = np.load(args.in_label_map)
labels = label_file['arr_0']
distance_file = np.load(args.in_distance_map)
distances_to_centroid_streamline = distance_file['arr_0']
if len(labels) != len(distances_to_centroid_streamline):
raise Exception(
"Label map doesn't contain the same number of entries as the "
"distance map. {} != {}".format(len(labels),
len(distances_to_centroid_streamline)))
# Compute stats
stats = get_bundle_metrics_mean_std_per_point(sft.streamlines, bundle_name,
distances_to_centroid_streamline,
metrics, labels,
args.density_weighting,
args.distance_weighting)
if args.out_json:
with open(args.out_json, 'w') as outfile:
json.dump(stats, outfile, indent=args.indent,
sort_keys=args.sort_keys)
else:
print(json.dumps(stats, indent=args.indent, sort_keys=args.sort_keys))
def main():
parser = _build_arg_parser()
args = parser.parse_args()
required = args.in_label
assert_inputs_exist(parser, required)
label_img = nib.load(args.in_label)
label_img_data = get_data_as_label(label_img)
if args.scilpy_lut:
with open(os.path.join(get_lut_dir(), args.scilpy_lut + '.json')) as f:
label_dict = json.load(f)
(label_indices, label_names) = zip(*label_dict.items())
else:
with open(args.custom_lut) as f:
label_dict = json.load(f)
(label_indices, label_names) = zip(*label_dict.items())
output_filenames = []
for label, name in zip(label_indices, label_names):
if int(label) != 0:
if args.out_prefix:
output_filenames.append(
os.path.join(
args.out_dir,
'{0}_{1}.nii.gz'.format(args.out_prefix, name)))
else:
output_filenames.append(
os.path.join(args.out_dir, '{0}.nii.gz'.format(name)))
assert_output_dirs_exist_and_empty(parser, args, [], optional=args.out_dir)
assert_outputs_exist(parser, args, output_filenames)
# Extract the voxels that match the label and save them to a file.
cnt_filename = 0
for label in label_indices:
if int(label) != 0:
split_label = np.zeros(label_img.shape, dtype=np.uint16)
split_label[np.where(label_img_data == int(label))] = label
split_image = nib.Nifti1Image(split_label,
label_img.affine,
header=label_img.header)
nib.save(split_image, output_filenames[cnt_filename])
cnt_filename += 1
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_bundle)
sft = load_tractogram_with_reference(parser, args, args.in_bundle)
streamlines = sft.streamlines
lengths = [0]
if streamlines:
lengths = list(length(streamlines))
print(json.dumps({'min_length': float(np.min(lengths)),
'mean_length': float(np.mean(lengths)),
'max_length': float(np.max(lengths)),
'std_length': float(np.std(lengths))},
indent=args.indent, sort_keys=args.sort_keys))
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.in_hdf5, args.in_fodf])
assert_outputs_exist(parser, args, [args.out_hdf5])
# HDF5 will not overwrite the file
if os.path.isfile(args.out_hdf5):
os.remove(args.out_hdf5)
fodf_img = nib.load(args.in_fodf)
nbr_cpu = validate_nbr_processes(parser, args, args.nbr_processes)
in_hdf5_file = h5py.File(args.in_hdf5, 'r')
keys = list(in_hdf5_file.keys())
in_hdf5_file.close()
if nbr_cpu == 1:
results_list = []
for key in keys:
results_list.append(_afd_rd_wrapper([args.in_hdf5, key, fodf_img,
args.sh_basis,
args.length_weighting]))
else:
pool = multiprocessing.Pool(nbr_cpu)
results_list = pool.map(_afd_rd_wrapper,
zip(itertools.repeat(args.in_hdf5),
keys,
itertools.repeat(fodf_img),
itertools.repeat(args.sh_basis),
itertools.repeat(args.length_weighting)))
pool.close()
pool.join()
shutil.copy(args.in_hdf5, args.out_hdf5)
out_hdf5_file = h5py.File(args.out_hdf5, 'a')
for key, afd_fixel, rd_fixel in results_list:
group = out_hdf5_file[key]
if 'afd_fixel' in group:
del group['afd_fixel']
group.create_dataset('afd_fixel', data=afd_fixel)
if 'rd_fixel' in group:
del group['rd_fixel']
group.create_dataset('rd_fixel', data=rd_fixel)
out_hdf5_file.close()
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.bundle])
assert_outputs_exists(parser, args, [args.filtered_bundle, args.outliers])
if args.alpha <= 0 or args.alpha > 1:
parser.error('--alpha should be ]0, 1]')
tractogram = nib.streamlines.load(args.bundle)
if int(tractogram.header['nb_streamlines']) == 0:
logging.warning("Bundle file contains no streamline")
return
streamlines = tractogram.streamlines
summary = outliers_removal_using_hierarchical_quickbundles(streamlines)
outliers, outliers_removed = prune(streamlines, args.alpha, summary)
outliers_cluster = Cluster(indices=outliers, refdata=streamlines)
outliers_removed_cluster = Cluster(indices=outliers_removed,
refdata=streamlines)
if len(outliers_removed_cluster) == 0:
print("All streamlines are considered outliers. Please lower the "
"--alpha parameter")
else:
outlier_removed_tractogram = LazyTractogram(
lambda: outliers_removed_cluster,
affine_to_rasmm=np.eye(4))
nib.streamlines.save(
outlier_removed_tractogram,
args.filtered_bundle,
header=tractogram.header)
if len(outliers_cluster) == 0:
print("No outlier found. Please raise the --alpha parameter")
else:
outlier_tractogram = LazyTractogram(
lambda: outliers_cluster,
affine_to_rasmm=np.eye(4))
nib.streamlines.save(
outlier_tractogram,
args.outliers,
header=tractogram.header)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.wm, args.gm, args.csf])
assert_outputs_exists(parser, args,
[args.include, args.exclude, args.interface])
# Load volume
wm_img = nib.load(args.wm)
img_affine = wm_img.affine
img_shape = wm_img.shape
wm_pve = wm_img.get_data()
gm_pve = nib.load(args.gm).get_data()
csf_pve = nib.load(args.csf).get_data()
sc_pve = nib.load(args.sc).get_data()
# distribute Sub-cortical to white/gray matter
gm_ratio = args.sc_include_val
wm_pve += (1.0 - gm_ratio) * sc_pve
gm_pve += gm_ratio * sc_pve
# Background
background = np.ones(img_shape)
background[gm_pve > 0.0] = 0.0
background[wm_pve > 0.0] = 0.0
background[csf_pve > 0.0] = 0.0
# Interface
interface = np.zeros(img_shape)
interface[gm_pve >= args.threshold] = 1.0
interface[wm_pve < args.threshold] = 0.0
# Include Exclude maps
include_map = gm_pve
include_map[background > 0.0] = 1.0
exclude_map = csf_pve
nib.Nifti1Image(include_map.astype('float32'),
img_affine).to_filename(args.include)
nib.Nifti1Image(exclude_map.astype('float32'),
img_affine).to_filename(args.exclude)
nib.Nifti1Image(interface.astype('float32'),
img_affine).to_filename(args.interface)
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])
# We don't assert the existence of any output here because there
# are many possible inputs/outputs.
bvals, bvecs = read_bvals_bvecs(args.bvals, args.bvecs)
bvals_min = bvals.min()
# TODO refactor those checks
# Should be min bval, then b0.
if bvals_min < 0 or bvals_min > 20:
raise ValueError(
'The minimal b-value is lesser than 0 or greater than 20. This '
'is highly suspicious. Please check your data to ensure '
'everything is correct. Value found: {}'.format(bvals_min))
b0_threshold = args.b0_thr
if b0_threshold < 0 or b0_threshold > 20:
raise ValueError('Invalid --b0_thr value (<0 or >20). This is '
'highly suspicious. Value found: {}'
.format(b0_threshold))
if not np.isclose(bvals_min, 0.0):
b0_threshold = b0_threshold if b0_threshold > bvals_min else bvals_min
logging.warning('No b=0 image. Setting b0_threshold to %s',
b0_threshold)
gtab = gradient_table(bvals, bvecs, b0_threshold=b0_threshold)
b0_idx = np.where(gtab.b0s_mask)[0]
logger.info('Number of b0 images in the data: %s', len(b0_idx))
if args.mean:
logger.info('Using mean of indices %s for b0', b0_idx)
_mean_in_time(args.dwi, b0_idx, args.output)
else:
if not args.all:
b0_idx = [b0_idx[0]]
logger.info("Keeping %s for b0", b0_idx)
_keep_time_step(args.dwi, b0_idx, args.output)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_seed_map, [args.tractogram])
# Seed map informations
seed_map_img = nib.load(args.in_seed_map)
seed_map_data = seed_map_img.get_fdata().astype(np.uint8)
seed_map_affine = seed_map_img.affine
# Load seed density as labels
values = np.delete(np.unique(seed_map_data), 0)
# Create colormap based on labels
cmap = actor.create_colormap(values, name=args.colormap, auto=False)
# Append opacity to colormap
cmap = np.concatenate((cmap, np.full(
(cmap.shape[0], 1), args.seed_opacity)),
axis=-1)
scene = window.Scene()
scene.background(tuple(map(int, args.background)))
seedroi_actor = actor.contour_from_label(seed_map_data,
seed_map_affine,
color=cmap)
scene.add(seedroi_actor)
# Load tractogram as tubes or lines, with color if specified
if args.tractogram:
tractogram = nib.streamlines.load(args.tractogram).tractogram
color = None
if args.tractogram_color:
color = tuple(map(int, args.tractogram_color))
line_actor = streamline_actor[args.tractogram_shape](
tractogram.streamlines,
opacity=args.tractogram_opacity,
colors=color,
linewidth=args.tractogram_width)
scene.add(line_actor)
# Showtime !
showm = window.ShowManager(scene, reset_camera=True)
showm.initialize()
showm.start()
def main():
parser = _build_args_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.tracts])
assert_outputs_exists(parser, args, [args.out])
check_tracts_support(parser, args.tracts, False)
check_tracts_same_format(parser, args.tracts, args.out)
if args.errorRate < 0.001 or args.errorRate > 1:
logging.warn(
'You are using an error rate of {}.\nWe recommend setting it '
'between 0.001 and 1.\n0.001 will do almost nothing to the tracts '
'while 1 will higly compress/linearize the tracts'.format(
args.errorRate))
compression_wrapper(args.tracts, args.out, args.errorRate)
def main():
parser = buildArgsParser()
args = parser.parse_args()
in_files = [args.json_stats]
if args.ignore_bundles:
in_files.append(args.ignore_bundles)
assert_inputs_exist(parser, *in_files)
assert_outputs_exists(parser, args, args.xlsx_stats)
_create_xlsx_from_json(args.json_stats,
args.xlsx_stats,
sort_subs=args.no_sort_subs,
sort_bundles=args.no_sort_bundles,
ignored_bundles_fpath=args.ignore_bundles,
stats_over_population=args.stats_over_population)
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)
sft = load_tractogram_with_reference(parser, args, args.in_tractogram)
if args.nb_pts_per_streamline:
new_sft = resample_streamlines_num_points(sft,
args.nb_pts_per_streamline)
else:
new_sft = resample_streamlines_step_size(sft, args.step_size)
save_tractogram(new_sft, args.out_tractogram)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
assert_inputs_exist(parser, [args.in_moving_tractogram,
args.in_target_file,
args.in_transfo], args.in_deformation)
assert_outputs_exist(parser, args, args.out_tractogram)
moving_sft = load_tractogram_with_reference(parser, args,
args.in_moving_tractogram,
bbox_check=False)
transfo = load_matrix_in_any_format(args.in_transfo)
deformation_data = None
if args.in_deformation is not None:
deformation_data = np.squeeze(nib.load(
args.in_deformation).get_fdata(dtype=np.float32))
new_sft = transform_warp_sft(moving_sft, transfo,
args.in_target_file,
inverse=args.inverse,
reverse_op=args.reverse_operation,
deformation_data=deformation_data,
remove_invalid=args.remove_invalid,
cut_invalid=args.cut_invalid)
if len(new_sft.streamlines) == 0:
if args.no_empty:
logging.debug("The file {} won't be written "
"(0 streamline).".format(args.out_tractogram))
return
if args.keep_invalid:
if not new_sft.is_bbox_in_vox_valid():
logging.warning('Saving tractogram with invalid streamlines.')
save_tractogram(new_sft, args.out_tractogram, bbox_valid_check=False)
else:
if not new_sft.is_bbox_in_vox_valid():
logging.warning('Removing invalid streamlines before '
'saving tractogram.')
new_sft.remove_invalid_streamlines()
save_tractogram(new_sft, args.out_tractogram)
def main():
parser = _build_args_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_files)
all_valid = True
for filepath in args.in_files:
_, in_extension = split_name_with_nii(filepath)
if in_extension not in ['.trk', '.nii', '.nii.gz']:
parser.error(
'{} does not have a supported extension'.format(filepath))
if not is_header_compatible(args.in_files[0], filepath):
print('{} and {} do not have compatible header.'.format(
args.in_files[0], filepath))
all_valid = False
if all_valid:
print('All input files have compatible headers.')
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_sh)
assert_outputs_exist(parser, args, args.out_sh)
sphere = get_sphere('repulsion724').subdivide(1)
img = nib.load(args.in_sh)
data = img.get_fdata(dtype=np.float32)
new_data = convert_sh_basis(data,
sphere,
input_basis=args.sh_basis,
nbr_processes=args.nbr_processes)
nib.save(nib.Nifti1Image(new_data, img.affine, header=img.header),
args.out_sh)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.in_bundle, args.in_fodf])
assert_outputs_exist(parser, args, [args.afd_mean_map, args.rd_mean_map])
sft = load_tractogram_with_reference(parser, args, args.in_bundle)
fodf_img = nib.load(args.in_fodf)
afd_mean_map, rd_mean_map = afd_map_along_streamlines(
sft, fodf_img, args.sh_basis, args.length_weighting)
nib.Nifti1Image(afd_mean_map.astype(np.float32),
fodf_img.affine).to_filename(args.afd_mean_map)
nib.Nifti1Image(rd_mean_map.astype(np.float32),
fodf_img.affine).to_filename(args.rd_mean_map)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.bundle])
assert_outputs_exists(parser, args, [args.centroid_streamline])
if args.distance_thres < 0.0:
parser.error('--distance_thres {} should be '
'positive'.format(args.distance_thres))
if args.nb_points < 2 or args.nb_points > 99:
parser.error('--nb_points {} should be [2, 99]'.format(args.nb_points))
tractogram = nib.streamlines.load(args.bundle)
centroid_streamline = get_centroid_streamline(tractogram, args.nb_points,
args.distance_thres)
nib.streamlines.save(centroid_streamline,
args.centroid_streamline,
header=tractogram.header)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, args.in_bundle)
assert_outputs_exist(parser, args, args.out_centroid)
if args.nb_points < 2:
parser.error('--nb_points {} should be >= 2'.format(args.nb_points))
sft = load_tractogram_with_reference(parser, args, args.in_bundle)
centroid_streamlines = get_streamlines_centroid(sft.streamlines,
args.nb_points)
sft = StatefulTractogram.from_sft(centroid_streamlines, sft)
save_tractogram(sft, args.out_centroid)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.voxel_label_map])
voxel_label_map_img = nib.load(args.voxel_label_map)
voxel_label_map_data = voxel_label_map_img.get_data()
spacing = voxel_label_map_img.header['pixdim'][1:4]
labels = np.unique(voxel_label_map_data.astype(np.uint8))[1:]
voxel_volume = np.prod(spacing)
stats = {args.bundle_name: {'volume': {}}}
for i in labels:
stats[args.bundle_name]['volume']['{:02}'.format(i)] =\
len(voxel_label_map_data[voxel_label_map_data == i]) * voxel_volume
print(json.dumps(stats, indent=args.indent, sort_keys=args.sort_keys))
def main():
parser = _build_args_parser()
args = parser.parse_args()
assert_inputs_exist(
parser, [args.in_tractogram, args.config_file, args.transformation])
for directory in args.models_directories:
if not os.path.isdir(directory):
parser.error('Input folder {0} does not exist'.format(directory))
assert_output_dirs_exist_and_empty(parser, args, args.output)
logging.basicConfig(
filename=os.path.join(args.output, 'logfile.txt'),
filemode='w',
format='%(asctime)s, %(name)s %(levelname)s %(message)s',
datefmt='%H:%M:%S',
level=args.log_level)
coloredlogs.install(level=args.log_level)
transfo = np.loadtxt(args.transformation)
if args.inverse:
transfo = np.linalg.inv(np.loadtxt(args.transformation))
with open(args.config_file) as json_data:
config = json.load(json_data)
voting = VotingScheme(
config,
args.models_directories,
transfo,
args.output,
tractogram_clustering_thr=args.tractogram_clustering_thr,
minimal_vote_ratio=args.minimal_vote_ratio,
multi_parameters=args.multi_parameters)
if args.seeds is None:
seeds = [random.randint(1, 1000)]
else:
seeds = args.seeds
voting(args.in_tractogram, nbr_processes=args.processes, seeds=seeds)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.input])
assert_outputs_exists(parser, args, [args.output])
if args.min_fit < 2:
parser.error('--min_fit should be at least 2. Current value: {}'
.format(args.min_fit))
if args.max_iter < 1:
parser.error('--max_iter should be at least 1. Current value: {}'
.format(args.max_iter))
if args.fit_thr <= 0:
parser.error('--fit_thr should be greater than 0. Current value: {}'
.format(args.fit_thr))
logging.basicConfig(level=getattr(logging, args.log))
in_img = nib.load(args.input)
in_data = in_img.get_data()
in_data_flat = in_data.flatten()
in_nzr_ind = np.nonzero(in_data_flat)
in_nzr_val = np.array(in_data_flat[in_nzr_ind])
X = in_nzr_ind[0][:, np.newaxis]
model_ransac = linear_model.RANSACRegressor(
base_estimator=linear_model.LinearRegression(),
min_samples=args.min_fit,
residual_threshold=args.fit_thr,
max_trials=args.max_iter)
model_ransac.fit(X, in_nzr_val)
outlier_mask = np.logical_not(model_ransac.inlier_mask_)
outliers = X[outlier_mask]
logging.info('# outliers: %s', len(outliers))
in_data_flat[outliers] = 0
out_data = np.reshape(in_data_flat, in_img.shape)
nib.save(nib.Nifti1Image(out_data, in_img.affine, in_img.header),
args.output)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.INFO)
# Checking args
outputs = [args.out_sh]
if args.out_sym:
outputs.append(args.out_sym)
assert_outputs_exist(parser, args, outputs)
assert_inputs_exist(parser, args.in_sh)
nbr_processes = validate_nbr_processes(parser, args)
# 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])
t0 = time.perf_counter()
logging.info('Executing angle-aware bilateral filtering.')
asym_sh = angle_aware_bilateral_filtering(
data, sh_order=sh_order,
sh_basis=args.sh_basis,
in_full_basis=full_basis,
sphere_str=args.sphere,
sigma_spatial=args.sigma_spatial,
sigma_angular=args.sigma_angular,
sigma_range=args.sigma_range,
use_gpu=args.use_gpu,
nbr_processes=nbr_processes)
t1 = time.perf_counter()
logging.info('Elapsed time (s): {0}'.format(t1 - t0))
logging.info('Saving filtered SH to file {0}.'.format(args.out_sh))
nib.save(nib.Nifti1Image(asym_sh, sh_img.affine), args.out_sh)
if args.out_sym:
_, orders = sph_harm_ind_list(sh_order, full_basis=True)
logging.info('Saving symmetric SH to file {0}.'.format(args.out_sym))
nib.save(nib.Nifti1Image(asym_sh[..., orders % 2 == 0], sh_img.affine),
args.out_sym)
