Dictionary bounds + standard OSIPI bounds

src/original/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):

src/original/IAR_LundUniversity/ivim_fit_method_modified_topopro.py

@@ -84,9 +84,9 @@ def __init__(self, gtab, bounds=[[0, 0.005, 1e-5], [1, 0.1, 0.004]], \
                                     (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):

src/standardized/ASD_MemorialSloanKettering_QAMPER_IVIM.py

@@ -64,16 +64,17 @@ def algorithm(self,dwi_arr, bval_arr, LB0, UB0, x0in):
         return D_arr/1000, f_arr, Dx_arr/1000, s0_arr
 
     def initialize(self, bounds, initial_guess):
-        if bounds is None:
+        if self.bounds is None:
             print('warning, no bounds were defined, so algorithm-specific default bounds are used')
             self.bounds=([1e-6, 0, 0.004, 0],[0.003, 1.0, 0.2, 5])
         else:
-            self.bounds=bounds
-        if initial_guess is None:
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
+        if self.initial_guess is None:
             print('warning, no initial guesses were defined, so algorithm-specific default initial guess is used')
             self.initial_guess = [0.001, 0.2, 0.01, 1]
         else:
-            self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
             self.use_initial_guess = True
         self.use_initial_guess = True
         self.use_bounds = True

src/standardized/IAR_LU_biexp.py

@@ -45,10 +45,19 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_biexp, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        if initial_guess is None:
+            self.use_initial_guess = False
+
         # Check the inputs
+        # Adapt the standardized bounds to the format of the specific algorithm
+        self.bounds = [[self.bounds["S0"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["D"][0]], 
+                       [self.bounds["S0"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["D"][1]]]
 
+        # Adapt the standardized initial guess to the format of the specific algorithm
+        self.initial_guess = [self.initial_guess["S0"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["D"]]
+
         # Initialize the algorithm
         if self.bvalues is not None:
             bvec = np.zeros((self.bvalues.size, 3))

src/standardized/IAR_LU_modified_mix.py

@@ -46,21 +46,26 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_modified_mix, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        self.use_initial_guess = False # This algorithm does not use initial guesses
 
         # Additional options
         self.stochastic = True
 
         # Check the inputs
-
+        # Adapt the standardized bounds to the format of the specific algorithm
+        self.bounds = [[self.bounds["f"][0], self.bounds["Dp"][0]*1000, self.bounds["D"][0]*1000], 
+                       [self.bounds["f"][1], self.bounds["Dp"][1]*1000, self.bounds["D"][1]*1000]]
+        #self.bounds = [[bounds["f"][0], bounds["f"][1]], [bounds["Dp"][0]*1000, bounds["Dp"][1]*1000], [bounds["D"][0]*1000, bounds["D"][1]*1000]]
+
         # 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, bounds=self.bounds, rescale_results_to_mm2_s=True)
+            self.IAR_algorithm = IvimModelVP(gtab, bounds=self.bounds, rescale_units=False, rescale_results_to_mm2_s=True)
         else:
             self.IAR_algorithm = None
 

src/standardized/IAR_LU_modified_topopro.py

@@ -45,8 +45,20 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_modified_topopro, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        self.use_initial_guess = False # This algorithm does not use initial guesses
+
+        # Additional options
+        self.stochastic = True
+
+        # Check the inputs
+        # Adapt the standardized bounds to the format of the specific algorithm
+        if self.bounds["Dp"][0] == self.bounds["D"][1]:
+            print('warning, bounds for D* and D are equal, this will likely cause fitting errors. Setting D_upper to 99 percent of D_upper')
+            self.bounds["D"][1] = self.bounds["D"][1]*0.99
+        self.bounds = [[self.bounds["f"][0], self.bounds["Dp"][0]*1000, self.bounds["D"][0]*1000], 
+                       [self.bounds["f"][1], self.bounds["Dp"][1]*1000, self.bounds["D"][1]*1000]]
         # Check the inputs
 
         # Initialize the algorithm

src/standardized/IAR_LU_segmented_2step.py

@@ -45,16 +45,25 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_segmented_2step, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        if initial_guess is None:
+            self.use_initial_guess = False
         # Check the inputs
+
+        # Adapt the bounds to the format needed for the algorithm
+        self.bounds = [[self.bounds["S0"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["D"][0]], \
+                       [self.bounds["S0"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["D"][1]]]
+
+        # Adapt the initial guess to the format needed for the algorithm
+        self.initial_guess = [self.initial_guess["S0"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["D"]]
 
         # 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, bounds=self.bounds, initial_guess=self.initial_guess, b_threshold=self.thresholds)
         else:
             self.IAR_algorithm = None

src/standardized/IAR_LU_segmented_3step.py

@@ -45,9 +45,18 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_segmented_3step, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        if initial_guess is None:
+            self.use_initial_guess = False
         # Check the inputs
+
+        # Adapt the bounds to the format needed for the algorithm
+        self.bounds = [[self.bounds["S0"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["D"][0]], \
+                       [self.bounds["S0"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["D"][1]]]
+
+        # Adapt the initial guess to the format needed for the algorithm
+        self.initial_guess = [self.initial_guess["S0"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["D"]]
 
         # Initialize the algorithm
         if self.bvalues is not None:

src/standardized/IAR_LU_subtracted.py

@@ -45,9 +45,18 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         super(IAR_LU_subtracted, self).__init__(bvalues, thresholds, bounds, initial_guess)
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
-        self.use_initial_guess = False
+        if bounds is None:
+            self.use_bounds = False
+        if initial_guess is None:
+            self.use_initial_guess = False
         # Check the inputs
+
+        # Adapt the bounds to the format needed for the algorithm
+        self.bounds = [[self.bounds["S0"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["D"][0]], \
+                       [self.bounds["S0"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["D"][1]]]
+
+        # Adapt the initial guess to the format needed for the algorithm
+        self.initial_guess = [self.initial_guess["S0"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["D"]]
 
         # Initialize the algorithm
         if self.bvalues is not None:

src/standardized/IVIM_NEToptim.py

@@ -67,8 +67,9 @@ def initialize(self, bounds, initial_guess, fitS0, traindata, SNR, n):
             self.training_data(self.bvalues,n=n,SNR=SNR)
         self.arg=Arg()
         if bounds is not None:
-            self.arg.net_pars.cons_min = bounds[0]  # Dt, Fp, Ds, S0
-            self.arg.net_pars.cons_max = bounds[1]  # Dt, Fp, Ds, S0
+            self.arg.net_pars.cons_min = np.array([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]])#bounds[0]  # Dt, Fp, Ds, S0
+            self.arg.net_pars.cons_max = np.array([self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])#bounds[1]  # Dt, Fp, Ds, S0
+            self.use_bounds = True
         if traindata is None:
             self.net = deep.learn_IVIM(self.train_data['data'], self.bvalues, self.arg)
         else:

src/standardized/OGC_AmsterdamUMC_Bayesian_biexp.py

@@ -63,12 +63,13 @@ def initialize(self, bounds=None, initial_guess=None, fitS0=True, prior_in=None,
             print('warning, no bounds were defined, so default bounds are used of [0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3]')
             self.bounds=([0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3])
         else:
-            self.bounds=bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if initial_guess is None:
             print('warning, no initial guesses were defined, so default bounds are used of  [0.001, 0.001, 0.01, 1]')
             self.initial_guess = [0.001, 0.001, 0.01, 1]
         else:
-            self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
         self.use_initial_guess = True
         self.use_bounds = True
         if thresholds is None:

src/standardized/OGC_AmsterdamUMC_biexp.py

@@ -54,12 +54,13 @@ def initialize(self, bounds, initial_guess, fitS0):
             print('warning, no bounds were defined, so default bounds are used of [0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3]')
             self.bounds=([0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3])
         else:
-            self.bounds=bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if initial_guess is None:
             print('warning, no initial guesses were defined, so default bounds are used of  [0.001, 0.001, 0.01, 1]')
             self.initial_guess = [0.001, 0.1, 0.01, 1]
         else:
-            self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
             self.use_initial_guess = True
         self.fitS0=fitS0
         self.use_initial_guess = True

src/standardized/OGC_AmsterdamUMC_biexp_segmented.py

@@ -53,12 +53,13 @@ def initialize(self, bounds, initial_guess, thresholds):
             print('warning, no bounds were defined, so default bounds are used of [0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3]')
             self.bounds=([0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3])
         else:
-            self.bounds=bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if initial_guess is None:
             print('warning, no initial guesses were defined, so default bounds are used of  [0.001, 0.001, 0.01, 1]')
             self.initial_guess = [0.001, 0.001, 0.01, 1]
         else:
-            self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
         self.use_initial_guess = True
         self.use_bounds = True
         if thresholds is None:

src/standardized/OJ_GU_bayesMATLAB.py

@@ -68,12 +68,13 @@ def initialize(self, bounds,initial_guess):
             print('warning, no bounds were defined, so default bounds are used of [0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3]')
             self.bounds=([0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3])
         else:
-            self.bounds=bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if initial_guess is None:
             print('warning, no initial guesses were defined, so default bounds are used of  [0.001, 0.001, 0.01, 1]')
             self.initial_guess = [0.001, 0.1, 0.01, 1]
         else:
-            self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
             self.use_initial_guess = True
         self.use_initial_guess = True
         self.use_bounds = True

src/standardized/OJ_GU_segMATLAB.py

@@ -67,7 +67,8 @@ def initialize(self, bounds, thresholds):
             print('warning, no bounds were defined, so algorithm-specific default bounds are used')
             self.bounds=([1e-6, 0, 0.003, 0],[0.003, 1.0, 0.2, 5])
         else:
-            self.bounds=bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         self.use_bounds = True
         if thresholds is None:
             self.thresholds = 200

src/standardized/PV_MUMC_biexp.py

@@ -41,7 +41,11 @@ def __init__(self, bvalues=None, thresholds=None, bounds=None, initial_guess=Non
         self.PV_algorithm = fit_least_squares
         if bounds is not None:
             print('warning, bounds from wrapper are not (yet) used in this algorithm')
-        self.use_bounds = False
+
+        self.bounds = ([self.bounds["S0"][0], self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0]],
+                       [self.bounds["S0"][1], self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1]])
+
+        self.use_bounds = True
         self.use_initial_guess = False
 
 

src/standardized/TCML_TechnionIIT_SLS.py

@@ -51,10 +51,12 @@ def initialize(self, bounds, fitS0,thresholds):
             self.bounds = ([0.0003, 0.001, 0.009, 0],[0.008, 0.5,0.04, 3])
         else:
             print('warning, although bounds are given, only D* is bounded)')
-            bounds=bounds
-            self.bounds = bounds
+            #bounds=bounds
+            #self.bounds = bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         self.fitS0=fitS0
-        self.use_bounds = False
+        self.use_bounds = True
         if thresholds is None:
             self.thresholds = 150
             print('warning, no thresholds were defined, so default bounds are used of  150')

src/standardized/TCML_TechnionIIT_lsqBOBYQA.py

@@ -51,13 +51,16 @@ def initialize(self, bounds, initial_guess, fitS0):
             print('warning, no bounds were defined, so default bounds are used of [0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3]')
             self.bounds = ([0, 0, 0.005, 0.7],[0.005, 1.0, 0.2, 1.3])
         else:
-            bounds=bounds
-            self.bounds = bounds
+            #bounds=bounds
+            #self.bounds = bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if initial_guess is None:
             print('warning, no initial guesses were defined, so default bounds are used of  [0.001, 0.001, 0.01, 1]')
             self.initial_guess = [0.001, 0.1, 0.02, 1]  # D, Dp, f, S0
         else:
-            self.initial_guess = initial_guess
+            #self.initial_guess = initial_guess
+            self.initial_guess = [self.initial_guess["D"], self.initial_guess["f"], self.initial_guess["Dp"], self.initial_guess["S0"]]
             self.use_initial_guess = True
         self.fitS0=fitS0
         self.use_initial_guess = True

src/standardized/TCML_TechnionIIT_lsq_sls_BOBYQA.py

@@ -51,15 +51,17 @@ def initialize(self, bounds, fitS0, thresholds):
             print('warning, no bounds were defined, so default bounds are used of ([0.0003, 0.001, 0.009, 0],[0.008, 1.0,0.04, 3])')
             self.bounds = ([0.0003, 0.001, 0.009, 0],[0.008, 1.0 ,0.04, 3])
         else:
-            bounds=bounds
-            self.bounds = bounds
+            #bounds=bounds
+            #self.bounds = bounds
+            self.bounds = ([self.bounds["D"][0], self.bounds["f"][0], self.bounds["Dp"][0], self.bounds["S0"][0]],
+                           [self.bounds["D"][1], self.bounds["f"][1], self.bounds["Dp"][1], self.bounds["S0"][1]])
         if thresholds is None:
             self.thresholds = 200
             print('warning, no thresholds were defined, so default bounds are used of  200')
         else:
             self.thresholds = thresholds
         self.fitS0=fitS0
-        self.use_bounds = False
+        self.use_bounds = True
         self.use_initial_guess = False
 
     def ivim_fit(self, signals, bvalues, **kwargs):