Preproc main merge prep

.github/workflows/PyPi_installer.yml

@@ -0,0 +1,32 @@
+# Publishes to TestPyPI when you push a tag starting with "test-v"
+on:
+  push:
+    tags:
+      - "test-v*"
+
+# Publishes to real PyPI when you create a proper GitHub release
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+
+      - name: Publish to TestPyPI
+        if: startsWith(github.ref, 'refs/tags/test-v')
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+
+      - name: Publish to PyPI
+        if: github.event_name == 'release'
+        uses: pypa/gh-action-pypi-publish@release/v1

CITATION.cff

@@ -0,0 +1,56 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "OSIPI TF2.4 IVIM-MRI Code Collection"
+version: 0.1.0
+date-released: 2026
+license: Apache-2.0
+repository-code: "https://github.com/OSIPI/TF2.4_IVIM-MRI_CodeCollection"
+authors:
+  - family-names: Jalnefjord
+    given-names: Oscar
+    orcid: "https://orcid.org/XXXX-XXXX-XXXX-XXXX"
+    affiliation: "University of Gothenburg"
+  - family-names: Rashid
+    given-names: Ivan A.
+    affiliation: "Lund University"
+  - family-names: Kuppens
+    given-names: Daan
+    affiliation: "Amsterdam University Medical Center"
+  - family-names: van der Thiel
+    given-names: Merel M.
+    affiliation: "Maastricht University Medical Center"
+  - family-names: van Houdt
+    given-names: Petra J.
+    affiliation: "Netherlands Cancer Institute"
+  - family-names: Voorter
+    given-names: Paulien H.M.
+    affiliation: "Maastricht University Medical Center"
+  - family-names: Peterson
+    given-names: Eric T.
+    affiliation: "SRI International"
+  - family-names: Gurney-Champion
+    given-names: Oliver J.
+    affiliation: "Amsterdam University Medical Center"
+preferred-citation:
+  type: article
+  title: "An open-source code repository for intravoxel incoherent motion analysis: ISMRM Open Science Initiative for Perfusion Imaging (OSIPI)"
+  authors:
+    - family-names: Jalnefjord
+      given-names: Oscar
+    - family-names: Rashid
+      given-names: Ivan A.
+    - family-names: Kuppens
+      given-names: Daan
+    - family-names: van der Thiel
+      given-names: Merel M.
+    - family-names: van Houdt
+      given-names: Petra J.
+    - family-names: Voorter
+      given-names: Paulien H.M.
+    - family-names: Peterson
+      given-names: Eric T.
+    - family-names: Gurney-Champion
+      given-names: Oliver J.
+  journal: "Magnetic Resonance in Medicine"
+  year: 2026
+  doi: "10.XXXX/XXXXXXX"  # fill in once published

conftest.py

@@ -282,8 +282,8 @@ def bound_input(datafile, algorithms):
         for algorithm in algorithms["algorithms"]:
             algorithm_dict = algorithms.get(algorithm, {})
             if not algorithm_dict.get('deep_learning',False):
-                xfail = {"xfail": name in algorithm_dict.get("xfail_names", {}),
-                    "strict": algorithm_dict.get("xfail_names", {}).get(name, True)}
+                xfail = {"xfail": name in algorithm_dict.get("xfail_names", {}) or "bounds" in algorithm_dict.get("xfail_names", {}),
+                    "strict": algorithm_dict.get("xfail_names", {}).get("bounds", algorithm_dict.get("xfail_names", {}).get(name,True))}
                 kwargs = algorithm_dict.get("options", {})
                 tolerances = algorithm_dict.get("tolerances", {})
                 requires_matlab = algorithm_dict.get("requires_matlab", False)

phantoms/MR_XCAT_qMRI/sim_ivim_sig.py

@@ -451,15 +451,29 @@ def parse_bvalues_file(file_path):
 
         voxel_selector_fraction = 0.5
         D, f, Ds = contrast_curve_calc()
-        ignore = np.isnan(D)
+        ignore = np.logical_or(np.logical_or(np.isnan(D),f<0.03),f>0.97)
         generic_data = {}
+        seen_combinations = set()
+
         for level, name in legend.items():
             if len(ignore) > level and ignore[level]:
                 continue
             selector = XCAT == level
             voxels = sig[selector]
             if len(voxels) < 1:
                 continue
+            D_val = np.median(Dim[selector], axis=0)
+            f_val = np.median(fim[selector], axis=0)
+            Dp_val = np.median(Dpim[selector], axis=0)
+
+            combo = (tuple(np.atleast_1d(D_val)),
+                     tuple(np.atleast_1d(f_val)),
+                     tuple(np.atleast_1d(Dp_val)))
+
+            if combo in seen_combinations:
+                continue
+
+            seen_combinations.add(combo)
             signals = np.squeeze(voxels[int(voxels.shape[0] * voxel_selector_fraction)]).tolist()
             generic_data[name] = {
                 'noise': noise,

pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "osipi-ivim"
+version = "0.1.0"
+description = "OSIPI TF2.4 IVIM-MRI Code Collection"
+license = {text = "Apache-2.0"}
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    {name = "Oscar Jalnefjord",       email = "oscar.jalnefjord@gu.se"},
+    {name = "Ivan A. Rashid"},
+    {name = "Daan Kuppens"},
+    {name = "Merel M. van der Thiel"},
+    {name = "Petra J. van Houdt"},
+    {name = "Paulien H.M. Voorter"},
+    {name = "Eric T. Peterson"},
+    {name = "Oliver J. Gurney-Champion", email = "o.j.gurney-champion@amsterdamumc.nl"},
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "nibabel",
+    "torch",
+    "torchio",
+    "joblib",
+    "dipy",
+    "cvxpy",
+    "nlopt",
+    "tqdm",
+    "pandas",
+    "statsmodels",
+    "ivimnet",
+    "super-ivim-dc>1.0.0",
+    "zenodo-get",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-json-report",
+]
+docs = [
+    "sphinx",
+    "sphinx_rtd_theme",
+]
+plot = [
+    "matplotlib",
+    "scienceplots",
+]
+all = [
+    "osipi-ivim[test,docs,plot]",
+]
+
+[project.urls]
+Repository = "https://github.com/OSIPI/TF2.4_IVIM-MRI_CodeCollection"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pytest.ini

@@ -3,6 +3,7 @@ markers =
     slow: marks tests as slow (deselect with '-m "not slow"')
 addopts =  
     -m 'not slow'
+    --ignore-glob=**/wip_*.py
 testpaths = tests
 filterwarnings =
     ignore::Warning

requirements.txt

@@ -18,4 +18,7 @@ sphinx_rtd_theme
 pytest-json-report
 statsmodels
 ivimnet
-nlopt
+nlopt
+nipype
+itk
+#ivim-mri

src/original/fitting/DT_IIITN/__init__.py

@@ -0,0 +1 @@
+# WLS IVIM fitting by Devguru Tiwari, IIIT Nagpur

src/original/fitting/DT_IIITN/wls_ivim_fitting.py

@@ -0,0 +1,170 @@
+"""
+Weighted Least Squares (WLS) / Robust Linear Model (RLM) IVIM fitting.
+
+Author: Devguru Tiwari, IIIT Nagpur
+Date: 2026-03-01
+
+Implements a segmented approach for IVIM parameter estimation:
+1. Estimate D from high b-values using weighted/robust linear regression on log-signal
+2. Estimate f from the intercept of the Step 1 fit
+3. Estimate D* from residuals at low b-values using weighted/robust linear regression
+
+Two regression methods are available:
+- WLS: Weighted Linear Least Squares with Veraart weights (w = S^2)
+- RLM: Robust Linear Model using Huber's T norm (statsmodels)
+
+Reference:
+    Veraart, J. et al. (2013). "Weighted linear least squares estimation of
+    diffusion MRI parameters: strengths, limitations, and pitfalls."
+    NeuroImage, 81, 335-346.
+    DOI: 10.1016/j.neuroimage.2013.05.028
+
+Requirements:
+    numpy
+    statsmodels (only for method="RLM")
+"""
+
+import numpy as np
+import warnings
+
+
+def _weighted_linreg(x, y, weights):
+    """Fast weighted linear regression: y = a + b*x.
+
+    Uses Veraart et al. (2013) approach with weights = S^2.
+
+    Args:
+        x: 1D array, independent variable.
+        y: 1D array, dependent variable.
+        weights: 1D array, weights for each observation.
+
+    Returns:
+        (intercept, slope) tuple.
+    """
+    W = np.diag(weights)
+    X = np.column_stack([np.ones_like(x), x])
+    # Weighted normal equations: (X^T W X) beta = X^T W y
+    XtW = X.T @ W
+    beta = np.linalg.solve(XtW @ X, XtW @ y)
+    return beta[0], beta[1]  # intercept, slope
+
+
+def _rlm_linreg(x, y):
+    """Robust linear regression using statsmodels RLM with Huber's T norm.
+
+    RLM down-weights outlier observations via iteratively reweighted least
+    squares (IRLS), making the fit resistant to corrupted/noisy voxels.
+
+    Args:
+        x: 1D array, independent variable.
+        y: 1D array, dependent variable.
+
+    Returns:
+        (intercept, slope) tuple.
+    """
+    import statsmodels.api as sm
+    X = sm.add_constant(x)
+    model = sm.RLM(y, X, M=sm.robust.norms.HuberT())
+    result = model.fit()
+    return result.params[0], result.params[1]  # intercept, slope
+
+
+def wls_ivim_fit(bvalues, signal, cutoff=200, method="WLS"):
+    """
+    IVIM fit using WLS or RLM (segmented approach).
+
+    Step 1: Fit D from high b-values on log-signal.
+    Step 2: Fit D* from residuals at low b-values.
+
+    Args:
+        bvalues (array-like): 1D array of b-values (s/mm²).
+        signal (array-like): 1D array of signal intensities (will be normalized).
+        cutoff (float): b-value threshold separating D from D* fitting.
+                        Default: 200 s/mm².
+        method (str): Regression method to use.
+            - "WLS": Weighted Least Squares with Veraart S² weights (default).
+            - "RLM": Robust Linear Model with Huber's T norm (statsmodels).
+
+    Returns:
+        tuple: (D, f, Dp) where
+            D (float): True diffusion coefficient (mm²/s).
+            f (float): Perfusion fraction (0-1).
+            Dp (float): Pseudo-diffusion coefficient (mm²/s).
+    """
+    method = method.upper()
+    if method not in ("WLS", "RLM"):
+        raise ValueError(f"Unknown method '{method}'. Use 'WLS' or 'RLM'.")
+
+    bvalues = np.array(bvalues, dtype=float)
+    signal = np.array(signal, dtype=float)
+
+    # Normalize signal to S(b=0)
+    s0_vals = signal[bvalues == 0]
+    if len(s0_vals) == 0 or np.mean(s0_vals) <= 0:
+        return 0.0, 0.0, 0.0
+    s0 = np.mean(s0_vals)
+    signal = signal / s0
+
+    try:
+        # ── Step 1: Estimate D from high b-values ─────────────────────
+        # At high b, perfusion component ≈ 0, so:
+        #   S(b) ≈ (1 - f) * exp(-b * D)
+        #   ln(S(b)) = ln(1 - f) - b * D
+        high_mask = bvalues >= cutoff
+        b_high = bvalues[high_mask]
+        s_high = signal[high_mask]
+
+        # Guard against zero/negative signal values
+        s_high = np.maximum(s_high, 1e-8)
+        log_s = np.log(s_high)
+
+        if method == "WLS":
+            # Veraart weights: w = S^2 (corrects for noise in log-domain)
+            weights_high = s_high ** 2
+            intercept, D = _weighted_linreg(-b_high, log_s, weights_high)
+        else:
+            # RLM: robust regression, no explicit weights needed
+            intercept, D = _rlm_linreg(-b_high, log_s)
+
+        # Extract f from intercept: intercept = ln(1 - f)
+        f = 1.0 - np.exp(intercept)
+
+        # Clamp to physically meaningful ranges
+        D = np.clip(D, 0, 0.005)
+        f = np.clip(f, 0, 1)
+
+        # ── Step 2: Estimate D* from low b-value residuals ────────────
+        # Subtract the diffusion component:
+        #   residual(b) = S(b) - (1 - f) * exp(-b * D)
+        #   ≈ f * exp(-b * D*)
+        #   ln(residual) = ln(f) - b * D*
+        residual = signal - (1 - f) * np.exp(-bvalues * D)
+
+        low_mask = (bvalues < cutoff) & (bvalues > 0)
+        b_low = bvalues[low_mask]
+        r_low = residual[low_mask]
+
+        # Guard against zero/negative residuals
+        r_low = np.maximum(r_low, 1e-8)
+        log_r = np.log(r_low)
+
+        if len(b_low) >= 2:
+            if method == "WLS":
+                weights_low = r_low ** 2
+                _, Dp = _weighted_linreg(-b_low, log_r, weights_low)
+            else:
+                _, Dp = _rlm_linreg(-b_low, log_r)
+            Dp = np.clip(Dp, 0.005, 0.2)
+        else:
+            Dp = 0.01  # fallback
+
+        # Ensure D* > D (by convention)
+        if Dp < D:
+            D, Dp = Dp, D
+            f = 1 - f
+
+        return D, f, Dp
+
+    except Exception:
+        # If fit fails, return zeros (consistent with other algorithms)
+        return 0.0, 0.0, 0.0

src/original/IAR_LundUniversity/ivim_fit_method_modified_mix.py → src/original/fitting/IAR_LundUniversity/ivim_fit_method_modified_mix.py

@@ -86,9 +86,9 @@ def __init__(self, gtab, bounds=None, maxiter=10, xtol=1e-8, rescale_units=False
                                     (bounds[0][1]*1000, bounds[1][1]*1000), \
                                     (bounds[0][2]*1000, bounds[1][2]*1000)])
         else: # Finally, if units if µm2/ms are already used
-            self.bounds = np.array([(bounds[0][0], bounds[1][0], \
+            self.bounds = np.array([(bounds[0][0], bounds[1][0]), \
                                     (bounds[0][1], bounds[1][1]), \
-                                    (bounds[0][2], bounds[1][2]))])
+                                    (bounds[0][2], bounds[1][2])])
 
     @multi_voxel_fit
     def fit(self, data, bounds_de=None):