Merge pull request #2172 from psavery/fix-flake8

Fix flake8 issues

Author: psavery

tomviz/python/Recon_tomopy_fxi.py

@@ -132,24 +132,24 @@ def recon(f, rot_cen, sli=[], binning=None, zero_flag=0, block_list=[],
         if 1: set negative pixel value to 0
         if 0: keep negative pixel value
     block_list: list
-        a list of index for the projections that will not be considered in reconstruction
+        a list of index for the projections that will not be considered in
+        reconstruction
 
     '''
     import tomopy
 
     tmp = np.array(f['img_tomo'][0])
     s = [1, tmp.shape[0], tmp.shape[1]]
-    slice_info = ''
 
     if len(sli) == 0:
         sli = [0, s[1]]
-    elif len(sli) == 1 and sli[0] >=0 and sli[0] <= s[1]:
+    elif len(sli) == 1 and sli[0] >= 0 and sli[0] <= s[1]:
         sli = [sli[0], sli[0]+1]
-        slice_info = '_slice_{}'.format(sli[0])
-    elif len(sli) == 2 and sli[0] >=0 and sli[1] <= s[1]:
-        slice_info = '_slice_{}_{}'.format(sli[0], sli[1])
+    elif len(sli) == 2 and sli[0] >= 0 and sli[1] <= s[1]:
+        pass
     else:
-        print('non valid slice id, will take reconstruction for the whole object')
+        print('non valid slice id, will take reconstruction for the whole',
+              'object')
     '''
     if len(col) == 0:
         col = [0, s[2]]
@@ -161,7 +161,7 @@ def recon(f, rot_cen, sli=[], binning=None, zero_flag=0, block_list=[],
         col = [0, s[2]]
         print('invalid col id, will take reconstruction for the whole object')
     '''
-    #rot_cen = rot_cen - col[0]
+    # rot_cen = rot_cen - col[0]
     theta = np.array(f['angle']) / 180.0 * np.pi
     pos = find_nearest(theta, theta[0]+np.pi)
     block_list = list(block_list) + list(np.arange(pos+1, len(theta)))
@@ -188,22 +188,25 @@ def recon(f, rot_cen, sli=[], binning=None, zero_flag=0, block_list=[],
         wiener_param['psf'] = np.ones([psf, psf])/(psf**2)
         wiener_param['reg'] = None
         wiener_param['balance'] = 0.3
-        wiener_param['is_real']=True
+        wiener_param['is_real'] = True
         wiener_param['clip'] = True
     else:
         add_slice = 0
         wiener_param = []
 
     try:
-        rec = np.zeros([s[0] // binning, s[1] // binning, s[1] // binning], dtype=np.float32)
-    except:
+        rec = np.zeros([s[0] // binning, s[1] // binning, s[1] // binning],
+                       dtype=np.float32)
+    except Exception:
         print('Cannot allocate memory')
 
     '''
     # first sli_step slices: will not do any denoising
-    prj_norm = proj_normalize(f, [0, sli_step], txm_normed_flag, binning, allow_list, bkg_level)
+    prj_norm = proj_normalize(f, [0, sli_step], txm_normed_flag, binning,
+                              allow_list, bkg_level)
     prj_norm = wiener_denoise(prj_norm, wiener_param, denoise_flag)
-    rec_sub = tomopy.recon(prj_norm, theta, center=rot_cen, algorithm='gridrec')
+    rec_sub = tomopy.recon(prj_norm, theta, center=rot_cen,
+                           algorithm='gridrec')
     rec[0 : rec_sub.shape[0]] = rec_sub
     '''
     # following slices
@@ -214,16 +217,22 @@ def recon(f, rot_cen, sli=[], binning=None, zero_flag=0, block_list=[],
         else:
             sli_sub = [i*sli_step+sli_total[0], (i+1)*sli_step+sli_total[0]]
             current_sli = [sli_sub[0]-add_slice, sli_sub[1]+add_slice]
-        print(f'recon {i+1}/{n_steps}:    sli = [{sli_sub[0]}, {sli_sub[1]}] ... ')
-        prj_norm = proj_normalize(f, current_sli, txm_normed_flag, binning, allow_list, bkg_level, denoise_level)
+        print(f'recon {i+1}/{n_steps}:    sli = [{sli_sub[0]},',
+              f'{sli_sub[1]}] ... ')
+        prj_norm = proj_normalize(f, current_sli, txm_normed_flag, binning,
+                                  allow_list, bkg_level, denoise_level)
         prj_norm = wiener_denoise(prj_norm, wiener_param, denoise_flag)
-        if i!=0 and i!=n_steps-1:
-            prj_norm = prj_norm[:, add_slice//binning:sli_step//binning+add_slice//binning]
-        rec_sub = tomopy.recon(prj_norm, theta, center=rot_cen, algorithm='gridrec')
-        rec[i*sli_step // binning : i*sli_step // binning + rec_sub.shape[0]] = rec_sub
+        if i != 0 and i != n_steps - 1:
+            start = add_slice // binning
+            stop = sli_step // binning + start
+            prj_norm = prj_norm[:, start:stop]
+        rec_sub = tomopy.recon(prj_norm, theta, center=rot_cen,
+                               algorithm='gridrec')
+        start = i * sli_step // binning
+        rec[start: start + rec_sub.shape[0]] = rec_sub
 
     if zero_flag:
-        rec[rec<0] = 0
+        rec[rec < 0] = 0
 
     return rec
 
@@ -240,35 +249,41 @@ def wiener_denoise(prj_norm, wiener_param, denoise_flag):
     is_real = wiener_param['is_real']
     clip = wiener_param['clip']
     for j in range(ss[0]):
-        prj_norm[j] = skr.wiener(prj_norm[j], psf=psf, reg=reg, balance=balance, is_real=is_real, clip=clip)
+        prj_norm[j] = skr.wiener(prj_norm[j], psf=psf, reg=reg,
+                                 balance=balance, is_real=is_real, clip=clip)
     return prj_norm
 
 
-def proj_normalize(f, sli, txm_normed_flag, binning, allow_list=[], bkg_level=0, denoise_level=9):
+def proj_normalize(f, sli, txm_normed_flag, binning, allow_list=[],
+                   bkg_level=0, denoise_level=9):
     import tomopy
 
     img_tomo = np.array(f['img_tomo'][:, sli[0]:sli[1], :])
     try:
         img_bkg = np.array(f['img_bkg_avg'][:, sli[0]:sli[1]])
-    except:
+    except Exception:
         img_bkg = []
     try:
         img_dark = np.array(f['img_dark_avg'][:, sli[0]:sli[1]])
-    except:
+    except Exception:
         img_dark = []
     if len(img_dark) == 0 or len(img_bkg) == 0 or txm_normed_flag == 1:
         prj = img_tomo
     else:
         prj = (img_tomo - img_dark) / (img_bkg - img_dark)
 
     s = prj.shape
-    prj = bin_ndarray(prj, (s[0], int(s[1]/binning), int(s[2]/binning)), 'mean')
+    prj = bin_ndarray(prj, (s[0], int(s[1] / binning), int(s[2] / binning)),
+                      'mean')
     prj_norm = -np.log(prj)
     prj_norm[np.isnan(prj_norm)] = 0
     prj_norm[np.isinf(prj_norm)] = 0
     prj_norm[prj_norm < 0] = 0
     prj_norm = prj_norm[allow_list]
-    prj_norm = tomopy.prep.stripe.remove_stripe_fw(prj_norm,level=denoise_level, wname='db5', sigma=1, pad=True)
+    prj_norm = tomopy.prep.stripe.remove_stripe_fw(prj_norm,
+                                                   level=denoise_level,
+                                                   wname='db5', sigma=1,
+                                                   pad=True)
     prj_norm -= bkg_level
     return prj_norm
 
@@ -294,19 +309,19 @@ def bin_ndarray(ndarray, new_shape=None, operation='mean'):
      [342 350 358 366 374]]
 
     """
-    if new_shape == None:
+    if new_shape is None:
         s = np.array(ndarray.shape)
-        s1 = np.int32(s/2)
+        s1 = np.int32(s / 2)
         new_shape = tuple(s1)
     operation = operation.lower()
-    if not operation in ['sum', 'mean']:
+    if operation not in ['sum', 'mean']:
         raise ValueError("Operation not supported.")
     if ndarray.ndim != len(new_shape):
         raise ValueError("Shape mismatch: {} -> {}".format(ndarray.shape,
                                                            new_shape))
-    compression_pairs = [(d, c//d) for d,c in zip(new_shape,
-                                                  ndarray.shape)]
-    flattened = [l for p in compression_pairs for l in p]
+    compression_pairs = [(d, c // d) for d, c in zip(new_shape,
+                                                     ndarray.shape)]
+    flattened = [x for p in compression_pairs for x in p]
     ndarray = ndarray.reshape(flattened)
     for i in range(len(new_shape)):
         op = getattr(ndarray, operation)
@@ -330,14 +345,16 @@ def rotcen_test(f, start=None, stop=None, steps=None, sli=0, block_list=[],
         psf = np.ones([psf, psf])/(psf**2)
         reg = None
         balance = 0.3
-        is_real=True
+        is_real = True
         clip = True
     else:
         addition_slice = 0
 
+    if sli == 0:
+        sli = int(s[1] / 2)
 
-    if sli == 0: sli = int(s[1]/2)
-    sli_exp = [np.max([0, sli-addition_slice//2]), np.min([sli+addition_slice//2+1, s[1]])]
+    sli_exp = [np.max([0, sli - addition_slice // 2]),
+               np.min([sli + addition_slice // 2 + 1, s[1]])]
 
     theta = np.array(f['angle']) / 180.0 * np.pi
 
@@ -357,11 +374,16 @@ def rotcen_test(f, start=None, stop=None, steps=None, sli=0, block_list=[],
 
     prj_norm -= bkg_level
 
-    prj_norm = tomopy.prep.stripe.remove_stripe_fw(prj_norm,level=denoise_level, wname='db5', sigma=1, pad=True)
-    if denoise_flag: # denoise using wiener filter
+    prj_norm = tomopy.prep.stripe.remove_stripe_fw(prj_norm,
+                                                   level=denoise_level,
+                                                   wname='db5', sigma=1,
+                                                   pad=True)
+    if denoise_flag:  # denoise using wiener filter
         ss = prj_norm.shape
         for i in range(ss[0]):
-           prj_norm[i] = skr.wiener(prj_norm[i], psf=psf, reg=reg, balance=balance, is_real=is_real, clip=clip)
+            prj_norm[i] = skr.wiener(prj_norm[i], psf=psf, reg=reg,
+                                     balance=balance, is_real=is_real,
+                                     clip=clip)
 
     s = prj_norm.shape
     if len(s) == 2:
@@ -374,7 +396,7 @@ def rotcen_test(f, start=None, stop=None, steps=None, sli=0, block_list=[],
         allow_list = list(set(np.arange(len(prj_norm))) - set(block_list))
         prj_norm = prj_norm[allow_list]
         theta = theta[allow_list]
-    if start==None or stop==None or steps==None:
+    if start is None or stop is None or steps is None:
         start = int(s[2]/2-50)
         stop = int(s[2]/2+50)
         steps = 26
@@ -383,6 +405,7 @@ def rotcen_test(f, start=None, stop=None, steps=None, sli=0, block_list=[],
     for i in range(len(cen)):
         if print_flag:
             print('{}: rotcen {}'.format(i+1, cen[i]))
-        img[i] = tomopy.recon(prj_norm[:, addition_slice:addition_slice+1], theta, center=cen[i], algorithm='gridrec')
+        img[i] = tomopy.recon(prj_norm[:, addition_slice:addition_slice + 1],
+                              theta, center=cen[i], algorithm='gridrec')
     img = tomopy.circ_mask(img, axis=0, ratio=0.8)
     return img, cen