pyAFQ 1.3__tar.gz → 1.3.2__tar.gz

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/api/bundle_dict.py

@@ -775,7 +775,6 @@ class BundleDict(MutableMapping):
         self.resample_to = resample_to
         self.resample_subject_to = resample_subject_to
         self.keep_in_memory = keep_in_memory
-        self.has_bids_info = False
         self.max_includes = 3
 
         self._dict = {}
@@ -787,7 +786,7 @@ class BundleDict(MutableMapping):
         if self.seg_algo == "afq":
             if "Forceps Major" in self.bundle_names\
                     and "Callosum Occipital" in self.bundle_names:
-                self.logger.warning((
+                self.logger.info((
                     "Forceps Major and Callosum Occipital bundles"
                     " are co-located, and AFQ"
                     " assigns each streamline to only one bundle."
@@ -795,7 +794,7 @@ class BundleDict(MutableMapping):
                 self.bundle_names.remove("Forceps Major")
             if "Forceps Minor" in self.bundle_names\
                     and "Callosum Orbital" in self.bundle_names:
-                self.logger.warning((
+                self.logger.info((
                     "Forceps Minor and Callosum Orbital bundles"
                     " are co-located, and AFQ"
                     " assigns each streamline to only one bundle."
@@ -803,7 +802,7 @@ class BundleDict(MutableMapping):
                 self.bundle_names.remove("Forceps Minor")
             if "Forceps Minor" in self.bundle_names\
                     and "Callosum Anterior Frontal" in self.bundle_names:
-                self.logger.warning((
+                self.logger.info((
                     "Forceps Minor and Callosum Anterior Frontal bundles"
                     " are co-located, and AFQ"
                     " assigns each streamline to only one bundle."
@@ -814,33 +813,23 @@ class BundleDict(MutableMapping):
         if new_max > self.max_includes:
             self.max_includes = new_max
 
-    def set_bids_info(self, bids_layout, bids_path, subject, session):
-        """
-        Provide the bids_layout, a nearest path,
-        and the subject and session information
-        to load ROIS from BIDS
-        """
-        self.has_bids_info = True
-        self._bids_info = bids_layout
-        self._bids_path = bids_path
-        self._subject = subject
-        self._session = session
-
-    def _cond_load(self, roi_or_sl, resample_to):
-        """
-        Load ROI or streamline if not already loaded
-        """
+    def _use_bids_info(self, roi_or_sl, bids_layout, bids_path,
+                       subject, session):
         if isinstance(roi_or_sl, dict):
-            if not self.has_bids_info:
-                raise ValueError((
-                    "Attempted to load an ROI using BIDS description without "
-                    "First providing BIDS information."))
             suffix = roi_or_sl.get("suffix", "dwi")
             roi_or_sl = find_file(
-                self._bids_info, self._bids_path,
+                bids_layout, bids_path,
                 roi_or_sl,
                 suffix,
-                self._session, self._subject)
+                session, subject)
+            return roi_or_sl
+        else:
+            return roi_or_sl
+
+    def _cond_load(self, roi_or_sl, resample_to):
+        """
+        Load ROI or streamline if not already loaded
+        """
         if isinstance(roi_or_sl, str):
             if self.seg_algo == "afq":
                 return afd.read_resample_roi(

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/api/group.py

@@ -3,6 +3,8 @@ import warnings
 import tempfile
 
 from AFQ.definitions.mapping import SynMap
+from AFQ.definitions.utils import Definition
+import AFQ.api.bundle_dict as abd
 warnings.simplefilter(action='ignore', category=FutureWarning)  # noqa
 
 import logging
@@ -22,6 +24,7 @@ from dipy.io.streamline import save_tractogram
 from AFQ.version import version as pyafq_version
 from AFQ.viz.utils import trim
 import pandas as pd
+import pydra
 import numpy as np
 import os
 import os.path as op
@@ -32,6 +35,7 @@ from time import time
 import nibabel as nib
 from PIL import Image
 from s3bids.utils import S3BIDSStudy
+import glob
 
 from bids.layout import BIDSLayout, BIDSLayoutIndexer
 try:
@@ -60,6 +64,17 @@ def get_afq_bids_entities_fname():
         aus.__file__))) + "/afq_bids_entities.json"
 
 
+class _ParticipantAFQInputs:
+    def __init__(
+            self, dwi_data_file, bval_file, bvec_file, results_dir,
+            kwargs):
+        self.dwi_data_file = dwi_data_file
+        self.bval_file = bval_file
+        self.bvec_file = bvec_file
+        self.results_dir = results_dir
+        self.kwargs = kwargs
+
+
 class GroupAFQ(object):
     f"""{AFQclass_doc}"""
 
@@ -146,6 +161,7 @@ class GroupAFQ(object):
         if not isinstance(bids_layout_kwargs, dict):
             raise TypeError("bids_layout_kwargs must be a dict")
 
+
         self.logger = logger
 
         self.parallel_params = parallel_params
@@ -252,6 +268,7 @@ class GroupAFQ(object):
         self.valid_sub_list = []
         self.valid_ses_list = []
         self.pAFQ_list = []
+        self.pAFQ_inputs_list = []
         for subject in self.subjects:
             self.wf_dict[subject] = {}
             for session in self.sessions:
@@ -296,20 +313,90 @@ class GroupAFQ(object):
                 if suffix is not None:
                     bids_filters["suffix"] = suffix
 
+                # Call find path for all definitions
+                for key, value in this_kwargs.items():
+                    if key == "scalars":
+                        for scalar in this_kwargs["scalars"]:
+                            if isinstance(scalar, Definition):
+                                scalar_found = scalar.find_path(
+                                    bids_layout,
+                                    dwi_data_file,
+                                    subject,
+                                    session,
+                                    required=False)
+                                if scalar_found is False:
+                                    this_kwargs["scalars"].remove(scalar)
+                    elif key == "import_tract":
+                        if isinstance(this_kwargs["import_tract"], dict):
+                            it_res = \
+                                bids_layout.get(
+                                    subject=subject,
+                                    session=session,
+                                    extension=[
+                                        '.trk',
+                                        '.tck',
+                                        '.vtk',
+                                        '.fib',
+                                        '.dpy'],
+                                    return_type='filename',
+                                    **this_kwargs["import_tract"])
+                            if len(it_res) < 1:
+                                raise ValueError((
+                                    "No custom tractography found for"
+                                    f" subject {subject}"
+                                    " and session "
+                                    f"{session}."))
+                            elif len(it_res) > 1:
+                                this_kwargs["import_tract"] = it_res[0]
+                                logger.warning((
+                                    f"Multiple viable custom tractographies found for"
+                                    f" subject "
+                                    f"{subject} and session "
+                                    f"{session}. Will use: {it_res[0]}"))
+                            else:
+                                this_kwargs["import_tract"] = it_res[0]
+                    elif isinstance(value, dict):
+                        for _, subvalue in value.items():
+                            if isinstance(subvalue, Definition):
+                                subvalue.find_path(
+                                    bids_layout,
+                                    dwi_data_file,
+                                    subject,
+                                    session)
+                    elif isinstance(value, Definition):
+                        value.find_path(
+                            bids_layout,
+                            dwi_data_file,
+                            subject,
+                            session)
+
+                # call find path for all ROIs
+                if "bundle_info" in this_kwargs and isinstance(
+                        this_kwargs["bundle_info"], abd.BundleDict):
+                    for b_name in this_kwargs["bundle_info"].bundle_names:
+                        this_kwargs["bundle_info"].apply_to_rois(
+                            b_name,
+                            this_kwargs["bundle_info"]._use_bids_info,
+                            bids_layout, bids_path, subject, session,
+                            dry_run=False)
+
                 self.valid_sub_list.append(subject)
                 self.valid_ses_list.append(str(session))
 
-                this_pAFQ = ParticipantAFQ(
+                this_pAFQ_inputs = _ParticipantAFQInputs(
                     dwi_data_file,
                     bval_file, bvec_file,
                     results_dir,
-                    bids_info={
-                        "bids_layout": bids_layout,
-                        "subject": subject,
-                        "session": session},
-                    **this_kwargs)
+                    this_kwargs)
+                this_pAFQ = ParticipantAFQ(
+                    this_pAFQ_inputs.dwi_data_file,
+                    this_pAFQ_inputs.bval_file,
+                    this_pAFQ_inputs.bvec_file,
+                    this_pAFQ_inputs.results_dir,
+                    **this_pAFQ_inputs.kwargs)
                 self.wf_dict[subject][str(session)] = this_pAFQ.wf_dict
                 self.pAFQ_list.append(this_pAFQ)
+                self.pAFQ_inputs_list.append(this_pAFQ_inputs)
 
     def combine_profiles(self):
         tract_profiles_dict = self.export("profiles")
@@ -916,6 +1003,139 @@ class GroupAFQ(object):
             sublink=page_subtitle_link)
 
 
+class ParallelGroupAFQ():
+    def __init__(self, *args, **kwargs):
+        orig = GroupAFQ(*args, **kwargs)
+
+        orig.parallel_params["submitter_params"] = \
+            orig.parallel_params.get("submitter_params", {"plugin": "cf"})
+        
+        orig.parallel_params["cache_dir"] = \
+            orig.parallel_params.get("cache_dir", None)
+
+        self.parallel_params = orig.parallel_params
+        self.pAFQ_kwargs = orig.pAFQ_inputs_list
+
+        self.finishing_params = dict()
+        self.finishing_params["args"] = args
+        self.finishing_params["kwargs"] = kwargs
+        self.finishing_params["output_dirs"] = [pAFQ.kwargs["output_dir"]
+                                                for pAFQ in orig.pAFQ_list]
+
+    def _submit_pydra(self, runnable):
+        try:
+            with pydra.Submitter(
+                **self.parallel_params["submitter_params"],
+            ) as sub:
+                sub(runnable=runnable)
+        # Addresses https://github.com/nipype/pydra/issues/630
+        except AttributeError as e:
+            if "'NoneType' object has no attribute 'replace'" not in str(e):
+                raise
+
+    def export(self, attr_name="help", collapse=True):
+        f"""
+        Export a specific output. To print a list of available outputs,
+        call export without arguments.
+        {valid_exports_string}
+
+        Parameters
+        ----------
+        attr_name : str
+            Name of the output to export. Default: "help"
+        collapse : bool
+            Whether to collapse session dimension if there is only 1 session.
+            Default: True
+
+        Returns
+        -------
+        output : dict
+            The specific output as a dictionary. Keys are subjects.
+            Values are dictionaries with keys of sessions
+            if multiple sessions are used. Otherwise, values are
+            the output.
+            None if called without arguments.
+        """
+
+        @pydra.mark.task
+        def export_sub(pAFQ_kwargs, attr_name):
+            pAFQ = ParticipantAFQ(
+                pAFQ_kwargs.dwi_data_file,
+                pAFQ_kwargs.bval_file,
+                pAFQ_kwargs.bvec_file,
+                pAFQ_kwargs.results_dir,
+                **pAFQ_kwargs.kwargs)
+            pAFQ.export(attr_name)
+
+        # Submit to pydra
+        export_sub_task = export_sub(
+            attr_name=attr_name,
+            cache_dir=self.parallel_params["cache_dir"]
+        ).split("pAFQ_kwargs", pAFQ_kwargs=self.pAFQ_kwargs)
+        self._submit_pydra(export_sub_task)
+
+    def export_all(self, viz=True, afqbrowser=True, xforms=True, indiv=True):
+        """ Exports all the possible outputs
+
+        Parameters
+        ----------
+        viz : bool
+            Whether to output visualizations. This includes tract profile
+            plots, a figure containing all bundles, and, if using the AFQ
+            segmentation algorithm, individual bundle figures.
+            Default: True
+        afqbrowser : bool
+            Whether to output an AFQ-Browser from this AFQ instance.
+            Default: True
+        xforms : bool
+            Whether to output the reg_template image in subject space and,
+            depending on if it is possible based on the mapping used, to
+            output the b0 in template space.
+            Default: True
+        indiv : bool
+            Whether to output individual bundles in their own files, in
+            addition to the one file containing all bundles. If using
+            the AFQ segmentation algorithm, individual ROIs are also
+            output.
+            Default: True
+        """
+        @pydra.mark.task
+        def export_sub(
+            pAFQ_kwargs,
+            finishing_params,
+            viz,
+            afqbrowser,
+            xforms,
+            indiv
+        ):
+            pAFQ = ParticipantAFQ(
+                pAFQ_kwargs.dwi_data_file,
+                pAFQ_kwargs.bval_file,
+                pAFQ_kwargs.bvec_file,
+                pAFQ_kwargs.results_dir,
+                **pAFQ_kwargs.kwargs)
+            pAFQ.export_all(viz, xforms, indiv)
+
+            for dir in finishing_params["output_dirs"]:
+                if not glob.glob(op.join(dir, "*_desc-profiles_dwi.csv")):
+                    return
+
+            gAFQ = GroupAFQ(*finishing_params["args"],
+                            **finishing_params["kwargs"])
+            gAFQ.export_all(viz, afqbrowser, xforms, indiv)
+
+        # Submit to pydra
+        export_sub_task = export_sub(
+            finishing_params=self.finishing_params,
+            viz=viz,
+            afqbrowser=afqbrowser,
+            xforms=xforms,
+            indiv=indiv,
+            cache_dir=self.parallel_params["cache_dir"]
+        ).split("pAFQ_kwargs", pAFQ_kwargs=self.pAFQ_kwargs)
+        self._submit_pydra(export_sub_task)
+
+
 def download_and_combine_afq_profiles(bucket,
                                       study_s3_prefix="", deriv_name=None,
                                       out_file=None,

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/api/participant.py

@@ -34,10 +34,9 @@ class ParticipantAFQ(object):
                  dwi_data_file,
                  bval_file, bvec_file,
                  output_dir,
-                 bids_info=None,
                  **kwargs):
         """
-        Initialize a ParticipantAFQ object from a BIDS dataset.
+        Initialize a ParticipantAFQ object.
 
         Parameters
         ----------
@@ -49,9 +48,6 @@ class ParticipantAFQ(object):
             Path to bvec file.
         output_dir : str
             Path to output directory.
-        bids_info : dict or None, optional
-            This is used by GroupAFQ to provide information about
-            the BIDS layout to each participant.
         kwargs : additional optional parameters
             You can set additional parameters for any step
             of the process. See :ref:`usage/kwargs` for more details.
@@ -70,9 +66,6 @@ class ParticipantAFQ(object):
         In tracking_params, parameters with the suffix mask which are also
         an image from AFQ.definitions.image will be handled automatically by
         the api.
-
-        It is recommended that you leave the bids_info parameter as None,
-        and instead pass in the paths to the files you want to use directly.
         """
         if not isinstance(output_dir, str):
             raise TypeError(
@@ -95,14 +88,12 @@ class ParticipantAFQ(object):
                 "did you mean tracking_params ?"))
 
         self.logger = logging.getLogger('AFQ')
-        self.output_dir = output_dir
 
         self.kwargs = dict(
-            dwi_path=dwi_data_file,
-            bval=bval_file,
-            bvec=bvec_file,
-            results_dir=output_dir,
-            bids_info=bids_info,
+            dwi_data_file=dwi_data_file,
+            bval_file=bval_file,
+            bvec_file=bvec_file,
+            output_dir=output_dir,
             base_fname=get_base_fname(output_dir, dwi_data_file),
             **kwargs)
         self.make_workflow()
@@ -113,15 +104,22 @@ class ParticipantAFQ(object):
                 self.kwargs["mapping_definition"], SlrMap):
             plans = {  # if using SLR map, do tractography first
                 "data": get_data_plan(self.kwargs),
-                "tractography": get_tractography_plan(self.kwargs),
-                "mapping": get_mapping_plan(self.kwargs, use_sls=True),
+                "tractography": get_tractography_plan(
+                    self.kwargs
+                ),
+                "mapping": get_mapping_plan(
+                    self.kwargs,
+                    use_sls=True
+                ),
                 "segmentation": get_segmentation_plan(self.kwargs),
                 "viz": get_viz_plan(self.kwargs)}
         else:
             plans = {  # Otherwise, do mapping first
                 "data": get_data_plan(self.kwargs),
                 "mapping": get_mapping_plan(self.kwargs),
-                "tractography": get_tractography_plan(self.kwargs),
+                "tractography": get_tractography_plan(
+                    self.kwargs
+                ),
                 "segmentation": get_segmentation_plan(self.kwargs),
                 "viz": get_viz_plan(self.kwargs)}
 
@@ -279,7 +277,7 @@ class ParticipantAFQ(object):
 
         def _save_file(curr_img):
             save_path = op.abspath(op.join(
-                self.output_dir,
+                self.kwargs["output_dir"],
                 "bundle_montage.png"))
             curr_img.save(save_path)
             all_fnames.append(save_path)
@@ -373,7 +371,7 @@ class ParticipantAFQ(object):
                     " to a filename and will be ignored."))
 
         apply_cmd_to_afq_derivs(
-            self.output_dir,
+            self.kwargs["output_dir"],
             self.export("base_fname"),
             cmd=cmd,
             exception_file_names=exception_file_names,

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/data/fetch.py

@@ -263,7 +263,7 @@ pediatric_md5_hashes = [
     "1c4c0823c23b676d6d35004d93b9c695", "d4830d558cc8f707ebec912b32d197a5",
     "c405e0dbd9a4091c77b3d1ad200229b4", "ec0aeccc6661d2ee5ed79259383cdcee",
     "2802cd227b550f6e85df0fec1d515c29", "385addb999dc6d76957d2a35c4ee74bb",
-    "b79f01829bd95682faaf545c72b1d52c", "b79f01829bd95682faaf545c72b1d52c",
+    "0dd14c02b272263adbe2246880979c9d", "99dac5a00c10d81d222f020162fd6194",
     "e49ba370edca96734d9376f551d413db", "f59e9e69e06325198f70047cd63c3bdc",
     "ae3bd2931f95adae0280a8f75cd3ca9b", "c409a0036b8c2dd4d03d11fbc6bfbdcd",
     "c2597a474ea5ec9e3126c35fd238f6b2", "67af59c934147c9f9ff6e0b76c4cc6eb",
@@ -303,7 +303,7 @@ pediatric_md5_hashes = [
 pediatric_remote_fnames = [
     "24880625", "24880628", "24880631", "24880634", "24880637", "24880640",
     "24880643", "24880646", "24880649", "24880652", "24880655", "24880661",
-    "24880664", "24880667", "24880670", "24880673", "24880676", "24880679",
+    "24880664", "24880667", "46407571", "46407568", "24880676", "24880679",
     "24880685", "24880688", "24880691", "24880694", "24880697", "24880700",
     "24880703", "24880706", "24880712", "24880715", "24880718", "24880721",
     "24880724", "24880727", "24880730", "24880733", "24880736", "24880748",
@@ -538,7 +538,7 @@ template_remote_fnames = ["5273680", "5273683", "5273686", "5273689",
                           "11458274", "11458277",
                           "5273695", "5273692", "5273698", "5273701",
                           "11458268", "11458271",
-                          "5273704", "5273707", "5273710", "5273713",
+                          "5273704", "5273707", "46407574", "46407577",
                           "11458262", "11458265",
                           "5273716", "5273719",
                           "11458220",
@@ -612,8 +612,8 @@ template_md5_hashes = ["6b7aaed1a2982fd0ea436a223133908b",
                        "7e73ab02db30a3ad6bd9e82148c2486e",
                        "f9db3154955a20b67c2dda758800d14c",
                        "73941510c798c1ed1b03e2bd481cd5c7",
-                       "660cdc031ee0716d60159c7d933119ea",
-                       "660cdc031ee0716d60159c7d933119ea",
+                       "b20e0caa54cf35002cd06cf6033b964f",
+                       "e751306df304af32c3ce7617913bbd30",
                        "fd012bc89f6bed7bd54530195496bac4",
                        "3406906a86e633cc102127cf210a1063",
                        "9040a7953dcbbf131d135c866182d8ef",

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/definitions/image.py

@@ -138,16 +138,13 @@ class ImageFile(ImageDefinition):
         if nearest_image is None:
             return False
 
-        if session not in self.fnames:
-            self.fnames[session] = {}
-        self.fnames[session][subject] = nearest_image
+        self.fnames[from_path] = nearest_image
 
-    def get_path_data_affine(self, bids_info):
+    def get_path_data_affine(self, dwi_path):
         if self._from_path:
             image_file = self.fname
         else:
-            image_file = self.fnames[
-                bids_info['session']][bids_info['subject']]
+            image_file = self.fnames[dwi_path]
         image_img = nib.load(image_file)
         return image_file, image_img.get_fdata(), image_img.affine
 
@@ -159,10 +156,10 @@ class ImageFile(ImageDefinition):
         return name_from_path(self.fname) if self._from_path else self.suffix
 
     def get_image_getter(self, task_name):
-        def _image_getter_helper(dwi, bids_info):
+        def _image_getter_helper(dwi, dwi_data_file):
             # Load data
             image_file, image_data_orig, image_affine = \
-                self.get_path_data_affine(bids_info)
+                self.get_path_data_affine(dwi_data_file)
 
             # Apply any conditions on the data
             image_data, meta = self.apply_conditions(
@@ -178,11 +175,11 @@ class ImageFile(ImageDefinition):
                 image_data.astype(np.float32),
                 dwi.affine), meta
         if task_name == "data":
-            def image_getter(dwi, bids_info):
-                return _image_getter_helper(dwi, bids_info)
+            def image_getter(dwi, dwi_data_file):
+                return _image_getter_helper(dwi, dwi_data_file)
         else:
-            def image_getter(data_imap, bids_info):
-                return _image_getter_helper(data_imap["dwi"], bids_info)
+            def image_getter(data_imap, dwi_data_file):
+                return _image_getter_helper(data_imap["dwi"], dwi_data_file)
         return image_getter
 
 

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/definitions/mapping.py

@@ -120,15 +120,14 @@ class FnirtMap(Definition):
             bids_layout, from_path, self.space_filters, self.space_suffix,
             session, subject, required=required)
 
-        self.fnames[session][subject] = (nearest_warp, nearest_space)
+        self.fnames[from_path] = (nearest_warp, nearest_space)
 
-    def get_for_subses(self, base_fname, dwi, bids_info, reg_subject,
+    def get_for_subses(self, base_fname, dwi, dwi_data_file, reg_subject,
                        reg_template):
         if self._from_path:
             nearest_warp, nearest_space = self.fnames
         else:
-            nearest_warp, nearest_space = self.fnames[
-                bids_info['session']][bids_info['subject']]
+            nearest_warp, nearest_space = self.fnames[dwi_data_file]
 
         our_templ = reg_template
         subj = Image(dwi)
@@ -182,7 +181,7 @@ class IdentityMap(Definition):
     def __init__(self):
         pass
 
-    def get_for_subses(self, base_fname, dwi, bids_info, reg_subject,
+    def get_for_subses(self, base_fname, dwi, dwi_data_file, reg_subject,
                        reg_template):
         return ConformedAffineMapping(
             np.identity(4),
@@ -231,7 +230,7 @@ class GeneratedMapMixin(object):
             write_json(meta_fname, meta)
         return prealign_file if save else np.load(prealign_file)
 
-    def get_for_subses(self, base_fname, dwi, bids_info, reg_subject,
+    def get_for_subses(self, base_fname, dwi, dwi_data_file, reg_subject,
                        reg_template, subject_sls=None, template_sls=None):
         mapping_file, meta_fname = self.get_fnames(
             self.extension, base_fname)

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/models/csd.py

@@ -23,7 +23,7 @@ class CsdNanResponseError(Exception):
     pass
 
 
-def _model(gtab, data, response=None, sh_order=None):
+def _model(gtab, data, response=None, sh_order=None, csd_fa_thr=0.7):
     """
     Helper function that defines a CSD model.
     """
@@ -50,7 +50,7 @@ def _model(gtab, data, response=None, sh_order=None):
         response, _ = csd.auto_response_ssst(response_gtab,
                                              data,
                                              roi_radii=10,
-                                             fa_thr=0.7)
+                                             fa_thr=csd_fa_thr)
     # Catch conditions where an auto-response could not be calculated:
     if np.all(np.isnan(response[0])):
         raise CsdNanResponseError
@@ -59,11 +59,13 @@ def _model(gtab, data, response=None, sh_order=None):
     return csdmodel
 
 
-def _fit(gtab, data, mask, response=None, sh_order=None, lambda_=1, tau=0.1):
+def _fit(gtab, data, mask, response=None, sh_order=None,
+         lambda_=1, tau=0.1, csd_fa_thr=0.7):
     """
     Helper function that does the core of fitting a model to data.
     """
-    return _model(gtab, data, response, sh_order).fit(data, mask=mask)
+    return _model(gtab, data, response, sh_order, csd_fa_thr).fit(
+        data, mask=mask)
 
 
 def fit_csd(data_files, bval_files, bvec_files, mask=None, response=None,

{pyAFQ-1.3 → pyafq-1.3.2}/AFQ/segmentation.py

@@ -482,6 +482,15 @@ class Segmentation:
         else:
             self.fiber_groups[b_name] = sl
 
+    def _add_bundle_to_meta(self, bundle_name, bundle_info):
+        bundle_info = bundle_info.copy()
+        # remove keys that can never be serialized
+        for key in [
+                'include', 'exclude', 'prob_map',
+                'start', 'end', 'curvature']:
+            bundle_info.pop(key, None)
+        self.meta[bundle_name] = bundle_info
+
     def segment_afq(self, tg=None):
         """
         Assign streamlines to bundles using the waypoint ROI approach
@@ -509,6 +518,7 @@ class Segmentation:
             dtype=np.uint32)
 
         self.fiber_groups = {}
+        self.meta = {}
 
         # We need to calculate the size of a voxel, so we can transform
         # from mm to voxel units:
@@ -862,10 +872,12 @@ class Segmentation:
                         sb_include_cuts, in_place=False)
                     self._add_bundle_to_fiber_group(
                         sb_name, bundlesection_select_sl, select_idx, to_flip)
+                    self._add_bundle_to_meta(sb_name, bundle_def)
             else:
                 self._add_bundle_to_fiber_group(
                     bundle, select_sl, select_idx, to_flip)
-        return self.fiber_groups
+                self._add_bundle_to_meta(bundle, bundle_def)
+        return self.fiber_groups, self.meta
 
     def move_streamlines(self, tg, to="template"):
         """Streamline-based registration of a whole-brain tractogram to
@@ -1052,7 +1064,7 @@ class Segmentation:
                                                           self.img,
                                                           Space.RASMM)
         self.fiber_groups = fiber_groups
-        return fiber_groups
+        return fiber_groups, {}
 
 
 def sl_curve(sl, n_points):