Hi all,
I’ve been tinkering with generating fiber bundles between two (manually drawn) ROIs, one in each hemisphere. Based on this post, I have been using the “targeted tracking method” which was a great resource and is working well!
tckgen wmfod.mif output_left.tck -seed_image left_roi.nii.gz -select 50000 -include right_roi.nii.gz -seed_unidirectional -stop
tckgen wmfod.mif output_right.tck -seed_image right_roi.nii.gz -select 50000 -include left_roi.nii.gz -seed_unidirectional -stop
tckedit output_left.tck output_right.tck joined.tck
However, I have also tried seeding from one ROI without the -include (second ROI) option which seems faster. Using tckedit to then remove fibers that don’t reach the second ROI.
For example
tckgen wmfod.mif output_left.tck -seed_image left_roi.nii.gz -select 50000 -seed_unidirectional -stop
tckedit output_left.tck output_left_edited.tck -include right_roi.nii.gz
tckgen wmfod.mif output_right.tck -seed_image right_roi.nii.gz -select 50000 -include left_roi.nii.gz -seed_unidirectional -stop
tckedit output_right.tck output_right_edited.tck -include left_roi.nii.gz
tckedit output_left_edited.tck output_right_edited.tck output_joined.tck
As I plan to do this quite a few times, speeding up the process is appealing. I’m not sure why the second method is faster (despite additional steps), or if this would cause problems in my output.
Could somebody wiser than me offer some advice? Currently I am sticking to the first method based on available information but would love to speed up my analysis if feasible.
Because it requires much less computation. In the first, “slow” method, you’re asking the algorithm for 50.000 tracks that run from the start to the target ROI. I.e., slightly simplified, the algorithm will come up with a streamline and check whether it runs through the target ROI. If it does, it’ll write it to the tck file, otherwise it’ll discard the streamline. This process will repeat for as long as it takes to come up with 50,000 streamlines that fulfill the selection criteria. Now, depending on the size of the target ROI, its distance from the seed ROI, and their anatomic relation, the probability of finding such a valid streamline might be quite low, meaning that tckgenneeds to come up with dozens of streamlines until it finds a valid one. Watch the output of tckgenwhile it runs, it tells you how many streamlines it came up with - this might well be a few million streamlines, which takes time.
In the second, “fast” method, you’re asking the algorithm for 50,000 streamlines that originate from the seed ROI, doesn’t matter where they go. You left out the target ROI, so tckgen will simply give you the first 50.000 streamlines it came up with. You then filter only the ones that run through the target ROI, which will be only a subset of the original 50,000 - check tckinfo output_left_edited.tck for the number of streamlines.
The second method will result in fewer streamlines, and these streamlines will continue beyond the target ROI. Whether this is a problem or not depends on the subsequent analysis you’re planning to do. The experts here in the forum might have further insight into whether there are other things to consider between the two approaches.
Will you do this once per subject, or will you extract multiple fiber bundles from the same subject?