pyAFQ 1.3.2__tar.gz → 1.3.4__tar.gz

{pyafq-1.3.2 → pyafq-1.3.4}/.github/workflows/docbuild.yml

@@ -6,9 +6,8 @@ jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
-      max-parallel: 4
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        python-version: ["3.11"]
 
     steps:
     - name: Checkout repo
@@ -31,7 +30,7 @@ jobs:
         cd docs
         make html
     - name: Upload docs
-      uses: actions/upload-artifact@v1
+      uses: actions/upload-artifact@v4
       with:
         name: docs
         path: docs/build/html

{pyafq-1.3.2 → pyafq-1.3.4}/.github/workflows/publish-to-test-pypi.yml

@@ -6,34 +6,34 @@ jobs:
     name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@master
-    - name: Set up Python 3.9
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.11
       uses: actions/setup-python@v1
       with:
-        python-version: 3.9
-    - name: Install pypa/build
+        python-version: 3.11
+    - name: Install pep517
       run: >-
         python -m
         pip install
-        build
+        pep517
         --user
     - name: Build a binary wheel and a source tarball
       run: >-
         python -m
-        build
-        --sdist
-        --wheel
-        --outdir dist/
+        pep517.build
+        --source
+        --binary
+        --out-dir dist/
         .
     - name: Publish distribution 📦 to Test PyPI
-      uses: pypa/gh-action-pypi-publish@master
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
         user: __token__
         password: ${{ secrets.test_pypi_password }}
-        repository_url: https://test.pypi.org/legacy/
+        repository-url: https://test.pypi.org/legacy/
     - name: Publish distribution 📦 to PyPI
       if: startsWith(github.event.ref, 'refs/tags')
-      uses: pypa/gh-action-pypi-publish@master
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
         user: __token__
-        password: ${{ secrets.pypi_password }}
+        password: ${{ secrets.pypi_password }}

{pyafq-1.3.2 → pyafq-1.3.4}/AFQ/_fixes.py

@@ -1,4 +1,5 @@
 import numpy as np
+import logging
 
 from scipy.special import lpmv, gammaln
 
@@ -12,6 +13,9 @@ from dipy.tracking.streamline import set_number_of_points
 from scipy.linalg import blas
 
 
+logger = logging.getLogger('AFQ')
+
+
 def gwi_odf(gqmodel, data):
     gqi_vector = np.real(
         squared_radial_component(np.dot(
@@ -163,9 +167,9 @@ def gaussian_weights(bundle, n_points=100, return_mahalnobis=False,
     ----------
     bundle : Streamlines
         The streamlines to weight.
-    n_points : int, optional
-        The number of points to resample to. *If the `bundle` is an array,
-        this input is ignored*. Default: 100.
+    n_points : int or None, optional
+        The number of points to resample to. If this is None, we assume bundle
+        is already resampled, and do not do any resampling. Default: 100.
     return_mahalanobis : bool, optional
         Whether to return the Mahalanobis distance instead of the weights.
         Default: False.
@@ -173,7 +177,10 @@ def gaussian_weights(bundle, n_points=100, return_mahalnobis=False,
         The statistic used to calculate the central tendency of streamlines in
         each node. Can be one of {`np.mean`, `np.median`} or other functions
         that have similar API. Default: `np.mean`
-
+    resample : bool, optional
+        Whether its necessary to resample the streamlines to the same number
+        of points. Only set to False if they are already resampled.
+        Default: True.
     Returns
     -------
     w : array of shape (n_streamlines, n_points)
@@ -182,38 +189,36 @@ def gaussian_weights(bundle, n_points=100, return_mahalnobis=False,
         coordinates at that node position across streamlines.
 
     """
-
-    # Resample to same length for each streamline
-    # if necessary
-    resample = False
-    if isinstance(bundle, np.ndarray):
-        if len(bundle.shape) > 2:
-            if bundle.shape[1] != n_points:
-                sls = bundle.tolist()
-                sls = [np.asarray(item) for item in sls]
-                resample = True
-    else:
-        resample = True
-    if resample:
-        sls = set_number_of_points(bundle, n_points)
+    if n_points is not None:
+        if isinstance(bundle, np.ndarray):
+            bundle = bundle.tolist()
+        if isinstance(bundle, list):
+            bundle = [np.asarray(item) for item in bundle]
+        sls = np.asarray(set_number_of_points(bundle, n_points))
     else:
         sls = bundle
 
-    # If there's only one fiber here, it gets the entire weighting:
-    if len(bundle) == 1:
+    n_sls, n_nodes, _ = sls.shape
+
+    if n_sls < 15:  # Cov^-1 unstable under this amount
+        weights = np.ones((n_sls, n_nodes))
+        logger.warning((
+            "Not enough streamlines for weight calculation, "
+            "weighting everything evenly"))
         if return_mahalnobis:
-            return np.array([np.nan])
+            return np.full((n_sls, n_nodes), np.nan)
         else:
-            return np.array([1])
-
-    n_sls, n_nodes, n_dim = sls.shape
-    weights = np.zeros((n_sls, n_nodes))
+            return weights / np.sum(weights, 0)
+    else:
+        weights = np.zeros((n_sls, n_nodes))
     diff = stat(sls, axis=0) - sls
     for i in range(n_nodes):
         # This should come back as a 3D covariance matrix with the spatial
         # variance covariance of this node across the different streamlines,
         # reorganized as an upper diagonal matrix for expected Mahalanobis
         cov = np.cov(sls[:, i, :].T, ddof=0)
+        while np.any(np.linalg.eigvals(cov) < 0):
+            cov += np.eye(cov.shape[0]) * 1e-12
 
         # calculate Mahalanobis for node in every fiber
         if np.any(cov > 0):

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

@@ -494,7 +494,6 @@ def baby_bd():
             "primary_axis_percentage": 40,
             "cross_midline": False,
             "mahal": {"distance_threshold": 4}}},
-        seg_algo="afq",
         resample_to=afd.read_pediatric_templates()[
             'UNCNeo-withCerebellum-for-babyAFQ'])
 
@@ -567,7 +566,7 @@ def reco_bd(n_bundles):
         Selects between 16 or 80 bundle atlas
     """
     templates = afd.read_hcp_atlas(n_bundles, as_file=True)
-    return BundleDict(templates, seg_algo="reco")
+    return BundleDict(templates)
 
 
 def cerebellar_bd():
@@ -695,12 +694,6 @@ class BundleDict(MutableMapping):
         custom bundles. See `Defining Custom Bundle Dictionaries`
         in the `usage` section of pyAFQ's documentation for details.
 
-    seg_algo: One of {"afq", "reco"}
-        The bundle segmentation algorithm to use.
-            "afq" : Use waypoint ROIs + probability maps, as described
-            in [Yeatman2012]_
-            "reco" : Use Recobundles [Garyfallidis2017]_
-
     resample_to : Nifti1Image or bool, optional
         If there are bundles in bundle_info with the 'space' attribute
         set to 'template', or with no 'space' attribute,
@@ -761,7 +754,6 @@ class BundleDict(MutableMapping):
 
     def __init__(self,
                  bundle_info,
-                 seg_algo="afq",
                  resample_to=None,
                  resample_subject_to=False,
                  keep_in_memory=False):
@@ -769,7 +761,6 @@ class BundleDict(MutableMapping):
             raise TypeError((
                 f"bundle_info must be a dict,"
                 f" currently a {type(bundle_info)}"))
-        self.seg_algo = seg_algo.lower()
         if resample_to is None:
             resample_to = afd.read_mni_template()
         self.resample_to = resample_to
@@ -783,31 +774,30 @@ class BundleDict(MutableMapping):
             self.__setitem__(key, item)
 
         self.logger = logging.getLogger('AFQ')
-        if self.seg_algo == "afq":
-            if "Forceps Major" in self.bundle_names\
-                    and "Callosum Occipital" in self.bundle_names:
-                self.logger.info((
-                    "Forceps Major and Callosum Occipital bundles"
-                    " are co-located, and AFQ"
-                    " assigns each streamline to only one bundle."
-                    " Only Callosum Occipital will be used."))
-                self.bundle_names.remove("Forceps Major")
-            if "Forceps Minor" in self.bundle_names\
-                    and "Callosum Orbital" in self.bundle_names:
-                self.logger.info((
-                    "Forceps Minor and Callosum Orbital bundles"
-                    " are co-located, and AFQ"
-                    " assigns each streamline to only one bundle."
-                    " Only Callosum Orbital will be used."))
-                self.bundle_names.remove("Forceps Minor")
-            if "Forceps Minor" in self.bundle_names\
-                    and "Callosum Anterior Frontal" in self.bundle_names:
-                self.logger.info((
-                    "Forceps Minor and Callosum Anterior Frontal bundles"
-                    " are co-located, and AFQ"
-                    " assigns each streamline to only one bundle."
-                    " Only Callosum Anterior Frontal will be used."))
-                self.bundle_names.remove("Forceps Minor")
+        if "Forceps Major" in self.bundle_names\
+                and "Callosum Occipital" in self.bundle_names:
+            self.logger.info((
+                "Forceps Major and Callosum Occipital bundles"
+                " are co-located, and AFQ"
+                " assigns each streamline to only one bundle."
+                " Only Callosum Occipital will be used."))
+            self.bundle_names.remove("Forceps Major")
+        if "Forceps Minor" in self.bundle_names\
+                and "Callosum Orbital" in self.bundle_names:
+            self.logger.info((
+                "Forceps Minor and Callosum Orbital bundles"
+                " are co-located, and AFQ"
+                " assigns each streamline to only one bundle."
+                " Only Callosum Orbital will be used."))
+            self.bundle_names.remove("Forceps Minor")
+        if "Forceps Minor" in self.bundle_names\
+                and "Callosum Anterior Frontal" in self.bundle_names:
+            self.logger.info((
+                "Forceps Minor and Callosum Anterior Frontal bundles"
+                " are co-located, and AFQ"
+                " assigns each streamline to only one bundle."
+                " Only Callosum Anterior Frontal will be used."))
+            self.bundle_names.remove("Forceps Minor")
 
     def update_max_includes(self, new_max):
         if new_max > self.max_includes:
@@ -831,15 +821,19 @@ class BundleDict(MutableMapping):
         Load ROI or streamline if not already loaded
         """
         if isinstance(roi_or_sl, str):
-            if self.seg_algo == "afq":
+            if ".nii" in roi_or_sl:
                 return afd.read_resample_roi(
                     roi_or_sl,
                     resample_to=resample_to)
-            elif self.seg_algo.startswith("reco"):
+            else:
                 return load_tractogram(
                     roi_or_sl,
                     'same',
                     bbox_valid_check=False).streamlines
+        elif isinstance(roi_or_sl, nib.Nifti1Image):
+            return afd.read_resample_roi(
+                roi_or_sl,
+                resample_to=resample_to)
         else:
             return roi_or_sl
 
@@ -859,7 +853,6 @@ class BundleDict(MutableMapping):
 
             return self.__class__(
                 new_bd,
-                seg_algo=self.seg_algo,
                 resample_to=self.resample_to,
                 resample_subject_to=self.resample_subject_to,
                 keep_in_memory=self.keep_in_memory)
@@ -924,13 +917,12 @@ class BundleDict(MutableMapping):
         """
         return self.__class__(
             self._dict.copy(),
-            seg_algo=self.seg_algo,
             resample_to=self.resample_to,
             resample_subject_to=self.resample_subject_to,
             keep_in_memory=self.keep_in_memory)
 
     def apply_to_rois(self, b_name, func, *args,
-                      dry_run=False,
+                      dry_run=False, apply_to_recobundles=False,
                       **kwargs):
         """
         Applies some transformation to all ROIs (include, exclude, end, start)
@@ -946,6 +938,11 @@ class BundleDict(MutableMapping):
         dry_run : bool
             Whether to actually apply changes returned by `func` to the ROIs.
             If has_return is False, dry_run is not used.
+        apply_to_recobundles : bool, optional
+            Whether to apply the transformation to recobundles
+            TRKs as well.
+            Default: False
+
         *args :
             Additional arguments for func
         **kwargs
@@ -957,27 +954,25 @@ class BundleDict(MutableMapping):
         the roi type and values are the transformed ROIs.
         """
         return_vals = {}
-        if self.seg_algo == "afq":
-            for roi_type in ["include", "exclude", "start", "end", "prob_map"]:
-                if roi_type in self._dict[b_name]:
-                    if roi_type in ["start", "end", "prob_map"]:
-                        return_vals[roi_type] = func(
-                            self._dict[b_name][roi_type], *args, **kwargs)
-                    else:
-                        changed_rois = []
-                        for _roi in self._dict[b_name][roi_type]:
-                            changed_rois.append(func(
-                                _roi, *args, **kwargs))
-                        return_vals[roi_type] = changed_rois
-        elif self.seg_algo.startswith("reco"):
-            if b_name == "whole_brain":
-                return_vals = func(
-                    self._dict[b_name], *args, **kwargs)
-            else:
-                for sl_type in ["sl", "centroid"]:
-                    return_vals[sl_type] = func(
-                        self._dict[b_name][sl_type],
-                        *args, **kwargs)
+        for roi_type in [
+                "include", "exclude",
+                "start", "end", "prob_map"]:
+            if roi_type in self._dict[b_name]:
+                if roi_type in ["start", "end", "prob_map"]:
+                    return_vals[roi_type] = func(
+                        self._dict[b_name][roi_type], *args, **kwargs)
+                else:
+                    changed_rois = []
+                    for _roi in self._dict[b_name][roi_type]:
+                        changed_rois.append(func(
+                            _roi, *args, **kwargs))
+                    return_vals[roi_type] = changed_rois
+        if apply_to_recobundles and "recobundles" in self._dict[b_name]:
+            return_vals["recobundles"] = {}
+            for sl_type in ["sl", "centroid"]:
+                return_vals["recobundles"][sl_type] = func(
+                    self._dict[b_name]["recobundles"][sl_type],
+                    *args, **kwargs)
         if not dry_run:
             for roi_type, roi in return_vals.items():
                 self._dict[b_name][roi_type] = roi
@@ -994,34 +989,36 @@ class BundleDict(MutableMapping):
         b_name : str
             Name of the bundle to be resampled.
         """
-        if self.seg_algo == "afq":
-            if self.is_bundle_in_template(b_name):
-                resample_to = self.resample_to
-            else:
-                resample_to = self.resample_subject_to
+        if self.is_bundle_in_template(b_name):
+            resample_to = self.resample_to
         else:
-            resample_to = None
+            resample_to = self.resample_subject_to
         return self.apply_to_rois(
             b_name,
             self._cond_load,
             resample_to,
-            dry_run=dry_run)
+            dry_run=dry_run,
+            apply_to_recobundles=True)
 
     def is_bundle_in_template(self, bundle_name):
         return "space" not in self._dict[bundle_name]\
             or self._dict[bundle_name]["space"] == "template"
 
-    def _roi_transform_helper(self, roi, mapping, new_affine, bundle_name):
-        roi = afd.read_resample_roi(roi, self.resample_to)
-        warped_img = auv.transform_inverse_roi(
-            roi.get_fdata(),
-            mapping,
-            bundle_name=bundle_name)
-        warped_img = nib.Nifti1Image(warped_img, new_affine)
-        return warped_img
+    def _roi_transform_helper(self, roi_or_sl, mapping,
+                              new_affine, bundle_name):
+        roi_or_sl = self._cond_load(roi_or_sl, self.resample_to)
+        if isinstance(roi_or_sl, nib.Nifti1Image):
+            warped_img = auv.transform_inverse_roi(
+                roi_or_sl.get_fdata(),
+                mapping,
+                bundle_name=bundle_name)
+            warped_img = nib.Nifti1Image(warped_img, new_affine)
+            return warped_img
+        else:
+            return roi_or_sl
 
     def transform_rois(self, bundle_name, mapping, new_affine,
-                       base_fname=None):
+                       base_fname=None, apply_to_recobundles=False):
         """
         Get the bundle definition with transformed ROIs
         for a given bundle into a
@@ -1042,6 +1039,10 @@ class BundleDict(MutableMapping):
             Base file path to save ROIs too. Additional BIDS
             descriptors will be added to this file path. If None,
             do not save the ROIs.
+        apply_to_recobundles : bool, optional
+            Whether to apply the transformation to recobundles
+            TRKs as well.
+            Default: False
 
         Returns
         -------
@@ -1057,13 +1058,15 @@ class BundleDict(MutableMapping):
                 mapping,
                 new_affine,
                 bundle_name,
-                dry_run=True)
+                dry_run=True,
+                apply_to_recobundles=apply_to_recobundles)
         else:
             transformed_rois = self.apply_to_rois(
                 bundle_name,
                 self._cond_load,
                 self.resample_subject_to,
-                dry_run=True)
+                dry_run=True,
+                apply_to_recobundles=apply_to_recobundles)
 
         if base_fname is not None:
             fnames = []
@@ -1086,10 +1089,6 @@ class BundleDict(MutableMapping):
             return transformed_rois
 
     def __add__(self, other):
-        if self.seg_algo != other.seg_algo:
-            raise ValueError((
-                "Adding BundleDicts where seg_algo do not match."
-                f"seg_algo's are {self.seg_algo} and {other.seg_algo}"))
         for resample in ["resample_to", "resample_subject_to"]:
             if not getattr(self, resample)\
                     or not getattr(other, resample)\
@@ -1119,7 +1118,6 @@ class BundleDict(MutableMapping):
                         f"{getattr(other, resample).header['dim']}"))
         return self.__class__(
             {**self._dict, **other._dict},
-            self.seg_algo,
             self.resample_to,
             self.resample_subject_to,
             self.keep_in_memory)

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

@@ -161,7 +161,7 @@ class GroupAFQ(object):
         if not isinstance(bids_layout_kwargs, dict):
             raise TypeError("bids_layout_kwargs must be a dict")
 
-
+        parallel_params["engine"] = parallel_params.get("engine", "serial")
         self.logger = logger
 
         self.parallel_params = parallel_params
@@ -377,7 +377,7 @@ class GroupAFQ(object):
                         this_kwargs["bundle_info"].apply_to_rois(
                             b_name,
                             this_kwargs["bundle_info"]._use_bids_info,
-                            bids_layout, bids_path, subject, session,
+                            bids_layout, dwi_data_file, subject, session,
                             dry_run=False)
 
                 self.valid_sub_list.append(subject)
@@ -441,40 +441,39 @@ class GroupAFQ(object):
             sls_dict = {}
             load_next_subject()  # load first subject
             for b in bundle_dict.keys():
-                if b != "whole_brain":
-                    for i in range(len(self.valid_sub_list)):
-                        seg_sft, mapping = subses_info[i]
-                        idx = seg_sft.bundle_idxs[b]
-                        # use the first subses that works
-                        # otherwise try each successive subses
-                        if len(idx) == 0:
-                            # break if we run out of subses
-                            if i + 1 >= len(self.valid_sub_list):
-                                break
-                            # load subses if not already loaded
-                            if i + 1 >= len(subses_info):
-                                load_next_subject()
-                            continue
-                        if len(idx) > 100:
-                            idx = np.random.choice(
-                                idx, size=100, replace=False)
-                        these_sls = seg_sft.sft.streamlines[idx]
-                        these_sls = dps.set_number_of_points(these_sls, 100)
-                        tg = StatefulTractogram(
-                            these_sls,
-                            seg_sft.sft,
-                            Space.RASMM)
-                        delta = dts.values_from_volume(
-                            mapping.forward,
-                            tg.streamlines, np.eye(4))
-                        moved_sl = dts.Streamlines(
-                            [d + s for d, s in zip(delta, tg.streamlines)])
-                        moved_sl = np.asarray(moved_sl)
-                        median_sl = np.median(moved_sl, axis=0)
-                        sls_dict[b] = {"coreFiber": median_sl.tolist()}
-                        for ii, sl_idx in enumerate(idx):
-                            sls_dict[b][str(sl_idx)] = moved_sl[ii].tolist()
-                        break
+                for i in range(len(self.valid_sub_list)):
+                    seg_sft, mapping = subses_info[i]
+                    idx = seg_sft.bundle_idxs[b]
+                    # use the first subses that works
+                    # otherwise try each successive subses
+                    if len(idx) == 0:
+                        # break if we run out of subses
+                        if i + 1 >= len(self.valid_sub_list):
+                            break
+                        # load subses if not already loaded
+                        if i + 1 >= len(subses_info):
+                            load_next_subject()
+                        continue
+                    if len(idx) > 100:
+                        idx = np.random.choice(
+                            idx, size=100, replace=False)
+                    these_sls = seg_sft.sft.streamlines[idx]
+                    these_sls = dps.set_number_of_points(these_sls, 100)
+                    tg = StatefulTractogram(
+                        these_sls,
+                        seg_sft.sft,
+                        Space.RASMM)
+                    delta = dts.values_from_volume(
+                        mapping.forward,
+                        tg.streamlines, np.eye(4))
+                    moved_sl = dts.Streamlines(
+                        [d + s for d, s in zip(delta, tg.streamlines)])
+                    moved_sl = np.asarray(moved_sl)
+                    median_sl = np.median(moved_sl, axis=0)
+                    sls_dict[b] = {"coreFiber": median_sl.tolist()}
+                    for ii, sl_idx in enumerate(idx):
+                        sls_dict[b][str(sl_idx)] = moved_sl[ii].tolist()
+                    break
 
             with open(sls_json_fname, 'w') as fp:
                 json.dump(sls_dict, fp)
@@ -590,11 +589,8 @@ class GroupAFQ(object):
             Default: True
         """
         start_time = time()
-        seg_params = self.export("segmentation_params", collapse=False)[
-            self.valid_sub_list[0]][self.valid_ses_list[0]]
-        seg_algo = seg_params.get("seg_algo", "AFQ")
 
-        export_all_helper(self, seg_algo, xforms, indiv, viz)
+        export_all_helper(self, xforms, indiv, viz)
 
         self.combine_profiles()
         if afqbrowser:
@@ -1009,7 +1005,7 @@ class ParallelGroupAFQ():
 
         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)
 

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

@@ -198,8 +198,7 @@ class ParticipantAFQ(object):
             Default: True
         """
         start_time = time()
-        seg_algo = self.export("segmentation_params").get("seg_algo", "AFQ")
-        export_all_helper(self, seg_algo, xforms, indiv, viz)
+        export_all_helper(self, xforms, indiv, viz)
         self.logger.info(
             f"Time taken for export all: {time() - start_time}")
 
@@ -366,7 +365,7 @@ class ParticipantAFQ(object):
             if isinstance(file_name, str):
                 exception_file_names.append(file_name)
             else:
-                self.logger.warn((
+                self.logger.warning((
                     f"The exception '{exception}' does not correspond"
                     " to a filename and will be ignored."))
 

{pyafq-1.3.2 → pyafq-1.3.4}/AFQ/api/utils.py

@@ -109,7 +109,7 @@ def check_attribute(attr_name):
         f"{attr_name} not found for export. {valid_exports_string}")
 
 
-def export_all_helper(api_afq_object, seg_algo, xforms, indiv, viz):
+def export_all_helper(api_afq_object, xforms, indiv, viz):
     if xforms:
         try:
             api_afq_object.export("b0_warped")
@@ -122,8 +122,7 @@ def export_all_helper(api_afq_object, seg_algo, xforms, indiv, viz):
 
     if indiv:
         api_afq_object.export("indiv_bundles")
-        if seg_algo == "AFQ":
-            api_afq_object.export("rois")
+        api_afq_object.export("rois")
     api_afq_object.export("sl_counts")
     api_afq_object.export("median_bundle_lengths")
     api_afq_object.export("profiles")
@@ -138,5 +137,4 @@ def export_all_helper(api_afq_object, seg_algo, xforms, indiv, viz):
             else:
                 api_afq_object.logger.warning(plot_err_message)
         api_afq_object.export("all_bundles_figure")
-        if seg_algo == "AFQ":
-            api_afq_object.export("indiv_bundles_figures")
+        api_afq_object.export("indiv_bundles_figures")