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()
for param in ['theta', 'curvature']:
# Default was removed for consistency.
if param not in args:
setattr(args, param, None)
assert_inputs_exist(parser, [args.sh_file, args.seed_file, args.mask_file])
assert_outputs_exists(parser, args, [args.output_file])
np.random.seed(args.seed)
mask_img = nib.load(args.mask_file)
mask_data = mask_img.get_data()
seeds = random_seeds_from_mask(
nib.load(args.seed_file).get_data(),
seeds_count=args.nts if 'nts' in args else args.npv,
seed_count_per_voxel='nts' not in args)
# Tracking is performed in voxel space
streamlines = LocalTracking(_get_direction_getter(args, mask_data),
BinaryTissueClassifier(mask_data),
seeds,
np.eye(4),
step_size=args.step_size,
max_cross=1,
maxlen=int(args.max_len / args.step_size) + 1,
fixedstep=True,
return_all=True)
filtered_streamlines = (s for s in streamlines
if args.min_len <= length(s) <= args.max_len)
if args.compress_streamlines:
filtered_streamlines = (compress_streamlines(s, args.tolerance_error)
for s in filtered_streamlines)
tractogram = LazyTractogram(lambda: filtered_streamlines,
affine_to_rasmm=mask_img.affine)
# Header with the affine/shape from mask image
header = {
Field.VOXEL_TO_RASMM: mask_img.affine.copy(),
Field.VOXEL_SIZES: mask_img.header.get_zooms(),
Field.DIMENSIONS: mask_img.shape,
Field.VOXEL_ORDER: ''.join(aff2axcodes(mask_img.affine))
}
# Use generator to save the streamlines on-the-fly
nib.streamlines.save(tractogram, args.output_file, header=header)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
if args.isVerbose:
logging.basicConfig(level=logging.DEBUG)
assert_inputs_exist(parser, [args.sh_file, args.seed_file, args.mask_file])
assert_outputs_exist(parser, args, [args.output_file])
if not nib.streamlines.is_supported(args.output_file):
parser.error('Invalid output streamline file format (must be trk or ' +
'tck): {0}'.format(args.output_file))
if not args.min_length > 0:
parser.error('minL must be > 0, {}mm was provided.'.format(
args.min_length))
if args.max_length < args.min_length:
parser.error(
'maxL must be > than minL, (minL={}mm, maxL={}mm).'.format(
args.min_length, args.max_length))
if args.compress:
if args.compress < 0.001 or args.compress > 1:
logging.warning(
'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.compress))
if args.npv and args.npv <= 0:
parser.error('Number of seeds per voxel must be > 0.')
if args.nt and args.nt <= 0:
parser.error('Total number of seeds must be > 0.')
mask_img = nib.load(args.mask_file)
mask_data = mask_img.get_data()
# Make sure the mask is isotropic. Else, the strategy used
# when providing information to dipy (i.e. working as if in voxel space)
# will not yield correct results.
fodf_sh_img = nib.load(args.sh_file)
if not np.allclose(np.mean(fodf_sh_img.header.get_zooms()[:3]),
fodf_sh_img.header.get_zooms()[0],
atol=1.e-3):
parser.error(
'SH file is not isotropic. Tracking cannot be ran robustly.')
if args.npv:
nb_seeds = args.npv
seed_per_vox = True
elif args.nt:
nb_seeds = args.nt
seed_per_vox = False
else:
nb_seeds = 1
seed_per_vox = True
voxel_size = fodf_sh_img.header.get_zooms()[0]
vox_step_size = args.step_size / voxel_size
seed_img = nib.load(args.seed_file)
seeds = track_utils.random_seeds_from_mask(
seed_img.get_data(),
seeds_count=nb_seeds,
seed_count_per_voxel=seed_per_vox,
random_seed=args.seed)
# Tracking is performed in voxel space
max_steps = int(args.max_length / args.step_size) + 1
streamlines = LocalTracking(_get_direction_getter(args, mask_data),
BinaryTissueClassifier(mask_data),
seeds,
np.eye(4),
step_size=vox_step_size,
max_cross=1,
maxlen=max_steps,
fixedstep=True,
return_all=True,
random_seed=args.seed)
scaled_min_length = args.min_length / voxel_size
scaled_max_length = args.max_length / voxel_size
filtered_streamlines = (
s for s in streamlines
if scaled_min_length <= length(s) <= scaled_max_length)
if args.compress:
filtered_streamlines = (compress_streamlines(s, args.compress)
for s in filtered_streamlines)
tractogram = LazyTractogram(lambda: filtered_streamlines,
affine_to_rasmm=seed_img.affine)
filetype = nib.streamlines.detect_format(args.output_file)
header = create_header_from_anat(seed_img, base_filetype=filetype)
# Use generator to save the streamlines on-the-fly
nib.streamlines.save(tractogram, args.output_file, header=header)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
assert_inputs_exist(parser, [args.in_odf, args.in_seed, args.in_mask])
assert_outputs_exist(parser, args, args.out_tractogram)
if not nib.streamlines.is_supported(args.out_tractogram):
parser.error('Invalid output streamline file format (must be trk or ' +
'tck): {0}'.format(args.out_tractogram))
verify_streamline_length_options(parser, args)
verify_compression_th(args.compress)
verify_seed_options(parser, args)
mask_img = nib.load(args.in_mask)
mask_data = get_data_as_mask(mask_img, dtype=bool)
# Make sure the data is isotropic. Else, the strategy used
# when providing information to dipy (i.e. working as if in voxel space)
# will not yield correct results.
odf_sh_img = nib.load(args.in_odf)
if not np.allclose(np.mean(odf_sh_img.header.get_zooms()[:3]),
odf_sh_img.header.get_zooms()[0], atol=1e-03):
parser.error(
'ODF SH file is not isotropic. Tracking cannot be ran robustly.')
if args.npv:
nb_seeds = args.npv
seed_per_vox = True
elif args.nt:
nb_seeds = args.nt
seed_per_vox = False
else:
nb_seeds = 1
seed_per_vox = True
voxel_size = odf_sh_img.header.get_zooms()[0]
vox_step_size = args.step_size / voxel_size
seed_img = nib.load(args.in_seed)
seeds = track_utils.random_seeds_from_mask(
seed_img.get_fdata(dtype=np.float32),
np.eye(4),
seeds_count=nb_seeds,
seed_count_per_voxel=seed_per_vox,
random_seed=args.seed)
# Tracking is performed in voxel space
max_steps = int(args.max_length / args.step_size) + 1
streamlines_generator = LocalTracking(
_get_direction_getter(args),
BinaryStoppingCriterion(mask_data),
seeds, np.eye(4),
step_size=vox_step_size, max_cross=1,
maxlen=max_steps,
fixedstep=True, return_all=True,
random_seed=args.seed,
save_seeds=args.save_seeds)
scaled_min_length = args.min_length / voxel_size
scaled_max_length = args.max_length / voxel_size
if args.save_seeds:
filtered_streamlines, seeds = \
zip(*((s, p) for s, p in streamlines_generator
if scaled_min_length <= length(s) <= scaled_max_length))
data_per_streamlines = {'seeds': lambda: seeds}
else:
filtered_streamlines = \
(s for s in streamlines_generator
if scaled_min_length <= length(s) <= scaled_max_length)
data_per_streamlines = {}
if args.compress:
filtered_streamlines = (
compress_streamlines(s, args.compress)
for s in filtered_streamlines)
tractogram = LazyTractogram(lambda: filtered_streamlines,
data_per_streamlines,
affine_to_rasmm=seed_img.affine)
filetype = nib.streamlines.detect_format(args.out_tractogram)
reference = get_reference_info(seed_img)
header = create_tractogram_header(filetype, *reference)
# Use generator to save the streamlines on-the-fly
nib.streamlines.save(tractogram, args.out_tractogram, header=header)
def main():
t_init = perf_counter()
parser = _build_arg_parser()
args = parser.parse_args()
if args.verbose:
logging.basicConfig(level=logging.INFO)
assert_inputs_exist(parser, [args.in_odf, args.in_mask, args.in_seed])
assert_outputs_exist(parser, args, args.out_tractogram)
if args.compress is not None:
verify_compression_th(args.compress)
odf_sh_img = nib.load(args.in_odf)
mask = get_data_as_mask(nib.load(args.in_mask))
seed_mask = get_data_as_mask(nib.load(args.in_seed))
odf_sh = odf_sh_img.get_fdata(dtype=np.float32)
t0 = perf_counter()
if args.npv:
nb_seeds = args.npv
seed_per_vox = True
elif args.nt:
nb_seeds = args.nt
seed_per_vox = False
else:
nb_seeds = 1
seed_per_vox = True
# Seeds are returned with origin `center`.
# However, GPUTracker expects origin to be `corner`.
# Therefore, we need to shift the seed positions by half voxel.
seeds = random_seeds_from_mask(seed_mask,
np.eye(4),
seeds_count=nb_seeds,
seed_count_per_voxel=seed_per_vox,
random_seed=args.rng_seed) + 0.5
logging.info('Generated {0} seed positions in {1:.2f}s.'.format(
len(seeds),
perf_counter() - t0))
voxel_size = odf_sh_img.header.get_zooms()[0]
vox_step_size = args.step_size / voxel_size
vox_max_length = args.max_length / voxel_size
vox_min_length = args.min_length / voxel_size
min_strl_len = int(vox_min_length / vox_step_size) + 1
max_strl_len = int(vox_max_length / vox_step_size) + 1
# initialize tracking
tracker = GPUTacker(odf_sh, mask, seeds, vox_step_size, min_strl_len,
max_strl_len, args.theta, args.sh_basis,
args.batch_size, args.forward_only, args.rng_seed)
# wrapper for tracker.track() yielding one TractogramItem per
# streamline for use with the LazyTractogram.
def tracks_generator_wrapper():
for strl, seed in tracker.track():
# seed must be saved in voxel space, with origin `center`.
dps = {'seeds': seed - 0.5} if args.save_seeds else {}
# TODO: Investigate why the streamline must NOT be shifted to
# origin `corner` for LazyTractogram.
strl *= voxel_size # in mm.
if args.compress:
strl = compress_streamlines(strl, args.compress)
yield TractogramItem(strl, dps, {})
# instantiate tractogram
tractogram = LazyTractogram.from_data_func(tracks_generator_wrapper)
tractogram.affine_to_rasmm = odf_sh_img.affine
filetype = nib.streamlines.detect_format(args.out_tractogram)
reference = get_reference_info(odf_sh_img)
header = create_tractogram_header(filetype, *reference)
# Use generator to save the streamlines on-the-fly
nib.streamlines.save(tractogram, args.out_tractogram, header=header)
logging.info('Saved tractogram to {0}.'.format(args.out_tractogram))
# Total runtime
logging.info('Total runtime of {0:.2f}s.'.format(perf_counter() - t_init))