Adapted my submissions to OsipiBase

Author: IvanARashid

src/original/IAR_LundUniversity/ivim_fit_method_modified_topopro.py

@@ -80,9 +80,9 @@ def __init__(self, gtab, bounds=[[0,1], [0.005, 0.1], [1e-5, 0.004]], \
             # Bounds expressed as (lower bound, upper bound) for [f, D*, D].
             self.bounds = np.array([(0, 1), (5, 100), (0, 4)])
         elif (bounds[0][1] <= 1) or rescale_units: # Realistically, if mm2/s units are used, D* bound is <= 1
-            self.bounds = np.array([(bounds[0][0], bounds[1][0]), \
-                                    (bounds[0][1]*1000, bounds[1][1]*1000), \
-                                    (bounds[0][2]*1000, bounds[1][2]*1000)])
+            self.bounds = np.array([(bounds[0][0], bounds[0][1]), \
+                                    (bounds[1][0]*1000, bounds[1][1]*1000), \
+                                    (bounds[2][0]*1000, bounds[2][1]*1000)])
         else: # Finally, if units if µm2/ms are already used
             self.bounds = np.array([(bounds[0][0], bounds[1][0], \
                                     (bounds[0][1], bounds[1][1]), \

src/standardized wip/IAR_LU_linear.py

@@ -0,0 +1,82 @@
+import numpy as np
+from dipy.core.gradients import gradient_table
+from src.wrappers.OsipiBase import OsipiBase
+from src.original.IAR_LundUniversity.ivim_fit_method_linear import IvimModelLinear
+
+
+class IAR_LU_linear(OsipiBase):
+    """
+    Bi-exponential fitting algorithm by Ivan A. Rashid, Lund University
+    """
+    
+    # I'm thinking that we define default attributes for each submission like this
+    # And in __init__, we can call the OsipiBase control functions to check whether
+    # the user inputs fulfil the requirements
+    
+    # Some basic stuff that identifies the algorithm
+    id_author = "Ivan A. Rashid, LU"
+    id_algorithm_type = "Linear fit"
+    id_return_parameters = "f, D"
+    id_units = "seconds per milli metre squared or milliseconds per micro metre squared"
+    
+    # Algorithm requirements
+    required_bvalues = 3
+    required_thresholds = [0,0] # Interval from "at least" to "at most", in case submissions allow a custom number of thresholds
+    required_bounds = False
+    required_bounds_optional = True # Bounds may not be required but are optional
+    required_initial_guess = False
+    required_initial_guess_optional = True
+    accepted_dimensions = 1 # Not sure how to define this for the number of accepted dimensions. Perhaps like the thresholds, at least and at most?
+    
+    def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=None, weighting=None, stats=False):
+        """
+            Everything this algorithm requires should be implemented here.
+            Number of segmentation thresholds, bounds, etc.
+            
+            Our OsipiBase object could contain functions that compare the inputs with
+            the requirements.
+        """
+        super(IAR_LU_linear, self).__init__(bvalues, thresholds, bounds, initial_guess)
+        
+        # Check the inputs
+        
+        # Initialize the algorithm
+        if self.bvalues is not None:
+            bvec = np.zeros((self.bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(self.bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelLinear(gtab)
+        else:
+            self.IAR_algorithm = None
+        
+    
+    def ivim_fit(self, signals, bvalues=None):
+        """Perform the IVIM fit
+
+        Args:
+            signals (array-like)
+            bvalues (array-like, optional): b-values for the signals. If None, self.bvalues will be used. Default is None.
+
+        Returns:
+            _type_: _description_
+        """
+        
+        if self.IAR_algorithm is None:
+            if bvalues is None:
+                bvalues = self.bvalues
+            else:
+                bvalues = np.asarray(bvalues)
+            
+            bvec = np.zeros((bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelLinear(gtab)
+            
+        fit_results = self.IAR_algorithm.fit(signals)
+        
+        f = fit_results.model_params[1]
+        D = fit_results.model_params[2]
+        
+        return f, D

src/standardized/IAR_LU_modified_mix.py

@@ -0,0 +1,83 @@
+import numpy as np
+from dipy.core.gradients import gradient_table
+from src.wrappers.OsipiBase import OsipiBase
+from src.original.IAR_LundUniversity.ivim_fit_method_modified_mix import IvimModelVP
+
+
+class IAR_LU_modified_mix(OsipiBase):
+    """
+    Bi-exponential fitting algorithm by Ivan A. Rashid, Lund University
+    """
+    
+    # I'm thinking that we define default attributes for each submission like this
+    # And in __init__, we can call the OsipiBase control functions to check whether
+    # the user inputs fulfil the requirements
+    
+    # Some basic stuff that identifies the algorithm
+    id_author = "Ivan A. Rashid, LU"
+    id_algorithm_type = "Bi-exponential fit"
+    id_return_parameters = "f, D*, D"
+    id_units = "seconds per milli metre squared or milliseconds per micro metre squared"
+    
+    # Algorithm requirements
+    required_bvalues = 4
+    required_thresholds = [0,0] # Interval from "at least" to "at most", in case submissions allow a custom number of thresholds
+    required_bounds = False
+    required_bounds_optional = True # Bounds may not be required but are optional
+    required_initial_guess = False
+    required_initial_guess_optional = True
+    accepted_dimensions = 1 # Not sure how to define this for the number of accepted dimensions. Perhaps like the thresholds, at least and at most?
+    
+    def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=None, weighting=None, stats=False):
+        """
+            Everything this algorithm requires should be implemented here.
+            Number of segmentation thresholds, bounds, etc.
+            
+            Our OsipiBase object could contain functions that compare the inputs with
+            the requirements.
+        """
+        super(IAR_LU_modified_mix, self).__init__(bvalues, thresholds, bounds, initial_guess)
+        
+        # Check the inputs
+        
+        # Initialize the algorithm
+        if self.bvalues is not None:
+            bvec = np.zeros((self.bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(self.bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelVP(gtab)
+        else:
+            self.IAR_algorithm = None
+        
+    
+    def ivim_fit(self, signals, bvalues=None):
+        """Perform the IVIM fit
+
+        Args:
+            signals (array-like)
+            bvalues (array-like, optional): b-values for the signals. If None, self.bvalues will be used. Default is None.
+
+        Returns:
+            _type_: _description_
+        """
+        
+        if self.IAR_algorithm is None:
+            if bvalues is None:
+                bvalues = self.bvalues
+            else:
+                bvalues = np.asarray(bvalues)
+            
+            bvec = np.zeros((bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelVP(gtab, rescale_results_to_mm2_s=True)
+            
+        fit_results = self.IAR_algorithm.fit(signals)
+        
+        f = fit_results.model_params[1]
+        Dstar = fit_results.model_params[2]
+        D = fit_results.model_params[3]
+        
+        return f, Dstar, D

src/standardized/IAR_LU_modified_topopro.py

@@ -0,0 +1,83 @@
+import numpy as np
+from dipy.core.gradients import gradient_table
+from src.wrappers.OsipiBase import OsipiBase
+from src.original.IAR_LundUniversity.ivim_fit_method_modified_topopro import IvimModelTopoPro
+
+
+class IAR_LU_modified_topopro(OsipiBase):
+    """
+    Bi-exponential fitting algorithm by Ivan A. Rashid, Lund University
+    """
+    
+    # I'm thinking that we define default attributes for each submission like this
+    # And in __init__, we can call the OsipiBase control functions to check whether
+    # the user inputs fulfil the requirements
+    
+    # Some basic stuff that identifies the algorithm
+    id_author = "Ivan A. Rashid, LU"
+    id_algorithm_type = "Bi-exponential fit"
+    id_return_parameters = "f, D*, D"
+    id_units = "seconds per milli metre squared or milliseconds per micro metre squared"
+    
+    # Algorithm requirements
+    required_bvalues = 4
+    required_thresholds = [0,0] # Interval from "at least" to "at most", in case submissions allow a custom number of thresholds
+    required_bounds = False
+    required_bounds_optional = True # Bounds may not be required but are optional
+    required_initial_guess = False
+    required_initial_guess_optional = True
+    accepted_dimensions = 1 # Not sure how to define this for the number of accepted dimensions. Perhaps like the thresholds, at least and at most?
+    
+    def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=None, weighting=None, stats=False):
+        """
+            Everything this algorithm requires should be implemented here.
+            Number of segmentation thresholds, bounds, etc.
+            
+            Our OsipiBase object could contain functions that compare the inputs with
+            the requirements.
+        """
+        super(IAR_LU_modified_topopro, self).__init__(bvalues, thresholds, bounds, initial_guess)
+        
+        # Check the inputs
+        
+        # Initialize the algorithm
+        if self.bvalues is not None:
+            bvec = np.zeros((self.bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(self.bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelTopoPro(gtab)
+        else:
+            self.IAR_algorithm = None
+        
+    
+    def ivim_fit(self, signals, bvalues=None):
+        """Perform the IVIM fit
+
+        Args:
+            signals (array-like)
+            bvalues (array-like, optional): b-values for the signals. If None, self.bvalues will be used. Default is None.
+
+        Returns:
+            _type_: _description_
+        """
+        
+        if self.IAR_algorithm is None:
+            if bvalues is None:
+                bvalues = self.bvalues
+            else:
+                bvalues = np.asarray(bvalues)
+            
+            bvec = np.zeros((bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelTopoPro(gtab, rescale_results_to_mm2_s=True)
+            
+        fit_results = self.IAR_algorithm.fit(signals)
+        
+        f = fit_results.model_params[1]
+        Dstar = fit_results.model_params[2]
+        D = fit_results.model_params[3]
+        
+        return f, Dstar, D

src/standardized/IAR_LU_segmented_2step.py

@@ -0,0 +1,83 @@
+import numpy as np
+from dipy.core.gradients import gradient_table
+from src.wrappers.OsipiBase import OsipiBase
+from src.original.IAR_LundUniversity.ivim_fit_method_segmented_2step import IvimModelSegmented2Step
+
+
+class IAR_LU_segmented_2step(OsipiBase):
+    """
+    Bi-exponential fitting algorithm by Ivan A. Rashid, Lund University
+    """
+    
+    # I'm thinking that we define default attributes for each submission like this
+    # And in __init__, we can call the OsipiBase control functions to check whether
+    # the user inputs fulfil the requirements
+    
+    # Some basic stuff that identifies the algorithm
+    id_author = "Ivan A. Rashid, LU"
+    id_algorithm_type = "Segmented bi-exponential fit"
+    id_return_parameters = "f, D*, D"
+    id_units = "seconds per milli metre squared or milliseconds per micro metre squared"
+    
+    # Algorithm requirements
+    required_bvalues = 4
+    required_thresholds = [0,0] # Interval from "at least" to "at most", in case submissions allow a custom number of thresholds
+    required_bounds = False
+    required_bounds_optional = True # Bounds may not be required but are optional
+    required_initial_guess = False
+    required_initial_guess_optional = True
+    accepted_dimensions = 1 # Not sure how to define this for the number of accepted dimensions. Perhaps like the thresholds, at least and at most?
+    
+    def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=None, weighting=None, stats=False):
+        """
+            Everything this algorithm requires should be implemented here.
+            Number of segmentation thresholds, bounds, etc.
+            
+            Our OsipiBase object could contain functions that compare the inputs with
+            the requirements.
+        """
+        super(IAR_LU_segmented_2step, self).__init__(bvalues, thresholds, bounds, initial_guess)
+        
+        # Check the inputs
+        
+        # Initialize the algorithm
+        if self.bvalues is not None:
+            bvec = np.zeros((self.bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(self.bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelSegmented2Step(gtab)
+        else:
+            self.IAR_algorithm = None
+        
+    
+    def ivim_fit(self, signals, bvalues=None):
+        """Perform the IVIM fit
+
+        Args:
+            signals (array-like)
+            bvalues (array-like, optional): b-values for the signals. If None, self.bvalues will be used. Default is None.
+
+        Returns:
+            _type_: _description_
+        """
+        
+        if self.IAR_algorithm is None:
+            if bvalues is None:
+                bvalues = self.bvalues
+            else:
+                bvalues = np.asarray(bvalues)
+            
+            bvec = np.zeros((bvalues.size, 3))
+            bvec[:,2] = 1
+            gtab = gradient_table(bvalues, bvec, b0_threshold=0)
+            
+            self.IAR_algorithm = IvimModelSegmented2Step(gtab)
+            
+        fit_results = self.IAR_algorithm.fit(signals)
+        
+        f = fit_results.model_params[1]
+        Dstar = fit_results.model_params[2]
+        D = fit_results.model_params[3]
+        
+        return f, Dstar, D