CompactionAnalyzer 1.0.1__tar.gz → 1.0.3__tar.gz

{CompactionAnalyzer-1.0.1 → compactionanalyzer-1.0.3}/CompactionAnalyzer/CompactionFunctions.py

@@ -2,12 +2,17 @@ import numpy as np
 from skimage import io
 from PIL import Image
 from skimage.filters import gaussian, threshold_otsu, threshold_yen
-import scipy.ndimage.morphology as scipy_morph
-import scipy.ndimage.measurements as scipy_meas
 from skimage.morphology import remove_small_objects
 import imageio
 from skimage import color
-from scipy.ndimage.morphology import distance_transform_edt
+try:
+    from scipy.ndimage import distance_transform_edt
+    import scipy.ndimage as scipy_morph
+    import scipy.ndimage as scipy_meas
+except ImportError:
+    from scipy.ndimage.morphology import distance_transform_edt
+    import scipy.ndimage.morphology as scipy_morph
+    import scipy.ndimage.measurements as scipy_meas
 import matplotlib.pyplot as plt
 import os
 import pandas as pd
@@ -69,6 +74,15 @@ def custom_mask(img,show_segmentation=True):
         dict: Dictionary with keys: mask, radius, centroid (x/y)
     """
     from roipoly import RoiPoly
+    import matplotlib
+    
+    # switch backend for roipoly
+    try:
+        mpl_backend = matplotlib.get_backend()
+        matplotlib.use('Qt5Agg')  
+    except:
+         print ("Switched to Qt5Agg Backend for Roipoly")
+         
     # need to install RoiPoly package via pip to use this function  
     height = img.shape[0]
     width  = img.shape[1]
@@ -93,7 +107,15 @@ def custom_mask(img,show_segmentation=True):
     # if show_segmentation:
     #     plt.figure()
     #     plt.subplot(121), plt.imshow(img)
-    #     plt.subplot(122), plt.imshow(mask)    
+    #     plt.subplot(122), plt.imshow(mask)
+
+    # switch to original backend
+    try:
+        matplotlib.use(mpl_backend)
+        print ("Switched Back")
+    except:
+        print ("Could not switched back")
+        
     return {'mask': mask, 'radius': radius, 'centroid': (cx, cy)} 
 
 def regional_maxima(img):
@@ -204,10 +226,11 @@ def StuctureAnalysisMain(fiber_list,
                          sigma_tensor = None ,          # sigma of applied gauss filter / window for structure tensor analysis in px
                                                         # should be in the order of the objects to analyze !! 
                                                         # 7 um for collagen 
-                         edge = 40   ,                  # Cutt of pixels at the edge since values at the border cannot be trusted
+                         edge = 15   ,                  # Cutt of pixels at the edge since values at the border cannot be trusted
                          segmention_thres = 1.0 ,       # for cell segemetntion, thres 1 equals normal otsu threshold , user also can specify gaus1 + gaus2 in segmentation if needed
                          seg_gaus1=0.5, seg_gaus2 = 100 , # 2 gaus filters used as bandpassfilter for local contrast enhancement; For seg_gaus2 = None a single gauss filter is applied
                          max_dist = None,               # optional: specify the maximal distance around cell center for analysis (in px)
+                         min_dist = None,               # optional: specify the minimals distance around cell center for analysis (in px)
                          regional_max_correction = True,# background correction using regional maxima approach
                          show_segmentation = False ,    # display the segmentation output
                          sigma_first_blur  = 0.5  ,     # slight first bluring of whole image before appplying the structure tensor
@@ -219,12 +242,14 @@ def StuctureAnalysisMain(fiber_list,
                          SaveNumpy = False       ,      # saves numpy arrays for later analysis - can create large data files
                          norm1=1,norm2 = 99  ,          # contrast spreading for input images between norm1- and norm2-percentile; values below norm1-percentile are set to zero and
                                                         # values above norm2-percentile are set to 1
+                                                        ### use norm1= 0,norm2 = 100 if no contras enhancement desired
                          seg_invert=False,              # if segmentation is inverted dark objects are detected inseated of bright objects
                          seg_iter = 1,                  # number of repetitions of  binary closing, dilation and filling holes steps
                          segmention_method="otsu",      #  use "otsu", "entropy" or "yen"  as segmentation method
                          segmention_min_area = 1000,    # small bjects below this px-area are removed during cell segmentation
                          load_segmentation = False,     # if True enter the path of the segementation.npy - file in path_seg
-                         path_seg = None):              # to load a mask
+                         path_seg = None,               # to load a mask
+                         ignore_cell_outline=False):    # if True the cell area is not set to nan and orientation are calculted everywhere - still the cell center is calculated from segmention    
     """
     Main analysis
     
@@ -268,7 +293,7 @@ def StuctureAnalysisMain(fiber_list,
                                  'SaveNumpy': [SaveNumpy], 'norm1': [norm1], 'norm2': [norm2],
                                  'seg_invert': [seg_invert], 'seg_iter': [seg_iter], 'segmention_method': [segmention_method],
                                  'load_segmentation': [load_segmentation], 'path_seg': [path_seg],
-                                 'max_dist': [max_dist]
+                                 'max_dist': [max_dist], 'min_dist': [min_dist]
                                  
                                  },
                   'Data' :   {'fiber_list': [fiber_list], 'cell_list': [cell_list], 'out_list': [out_list]}
@@ -278,20 +303,20 @@ def StuctureAnalysisMain(fiber_list,
   
             
         # load images
-        im_cell  = imageio.imread(cell_list[n])  #color.rgb2gray(..)
-        im_fiber = imageio.imread(fiber_list[n])   #color.rgb2gray()
+        im_cell  = imageio.v2.imread(cell_list[n])  #color.rgb2gray(..)
+        im_fiber = imageio.v2.imread(fiber_list[n])   #color.rgb2gray()
         
         ## if 3 channels convert to grey  
         if len(im_cell.shape) == 3 :
             im_cell = color.rgb2gray(im_cell)
         if len(im_fiber.shape) == 3 :
             im_fiber = color.rgb2gray(im_fiber)    
-        
+       
         # # applying normalizing/ contrast spreading
         im_cell_n = normalize(im_cell, norm1, norm2)
         im_fiber_n = normalize(im_fiber, norm1, norm2)  
         im_fiber_g = gaussian(im_fiber_n, sigma=sigma_first_blur)     # blur fiber image slightly (test with local gauss - similar)
-        
+
 
         # segment cell (either manual or automatically)
         if manual_segmention==True:
@@ -308,20 +333,30 @@ def StuctureAnalysisMain(fiber_list,
         # center of the new cropped image (to avoid edge effects)
         center_small = (segmention["centroid"][0]-edge,segmention["centroid"][1]-edge)
         
-        # set segmention mask to nan to avoid effects within cell  (maybe not needed if signal below cell makes sense)
-        im_fiber_g_forstructure = im_fiber_g.copy()
-        im_fiber_g_forstructure[segmention["mask"]] = np.nan
-     
+       
+        ## do not set cell area to nan and but only use center from segmention if activaed
+        if ignore_cell_outline is True:
+            im_fiber_g_forstructure = im_fiber_g.copy() 
+        else:
+            # set segmention mask to nan to avoid effects within cell  (maybe not needed if signal below cell makes sense)
+            im_fiber_g_forstructure = im_fiber_g.copy()    
+            im_fiber_g_forstructure[segmention["mask"]] = np.nan
+            
+            
+        
         """
         Structure tensor
         """
         # Structure Tensor Orientation
         # get structure tensor
         ori, max_evec, min_evec, max_eval, min_eval = analyze_local(im_fiber_g_forstructure, sigma=sigma_tensor, size=0, filter_type="gaussian")
+  
         # cut off edges as specified
         if edge != 0:
             ori, max_evec, min_evec, max_eval, min_eval = ori[edge:-edge,edge:-edge], max_evec[edge:-edge,edge:-edge], min_evec[edge:-edge,edge:-edge], \
                                                           max_eval[edge:-edge,edge:-edge], min_eval[edge:-edge,edge:-edge]
+        
+
         """
         coordinates
         """
@@ -334,31 +369,32 @@ def StuctureAnalysisMain(fiber_list,
         dx_norm = (dx/distance)
         dy_norm = (dy/distance)
         dist_surface = distance_transform_edt(~segmention["mask"])[edge:-edge,edge:-edge] # dist to surface
-    
-          
+        # calculate an angle without the deviation/reference to the cell position
+        angle_no_reference = np.arctan2(min_evec[:,:,0],min_evec[:,:,1])*360/(2*np.pi)
+               
+        
         """
         total image analysis
         """
-        # Angular deviation from orietation to center vector - 
+        # Angular deviation from orietation to center vector (projection to only have positive deviation angle values since negative/positive deviation does not matter here)
         angle_dev = np.arccos(np.abs(dx_norm * min_evec[:,:,0] + dy_norm*min_evec[:,:,1])) * 360/(2*np.pi) 
-        # calculate oreination from angle_dev since they are normal distributed and np.abs((dx_norm * min_evec[:,:,0] + dy_norm*min_evec[:,:,1])) is not
-        orientation_dev_01 = angle_dev/90  
-        # orientation_dev_01 = np.abs((dx_norm * min_evec[:,:,0] + dy_norm*min_evec[:,:,1]))
-        orientation_dev = -(2*orientation_dev_01-1)  # norm from -1 to 1 ; changed sign
-        
+        ## compute the orientation 
+        orientation_dev =  1 - (2 * np.arccos(np.abs(dx_norm * min_evec[:,:,0] + dy_norm*min_evec[:,:,1]))/ (0.5* np.pi)) 
+       
+           
         ### set values to nan if max distance is specified
         ## for following analysis then only orientation within a certtain distance to the cell are used
         if max_dist:
-            angle_dev[distance>=max_dist] = np.nan
-            ori[distance>=max_dist] = np.nan
-            angle[distance>=max_dist] = np.nan # also for angular evaluation
+            angle_dev[distance>max_dist] = np.nan
+            ori[distance>max_dist] = np.nan
+            angle[distance>max_dist] = np.nan # also for angular evaluation
   
-        # weighting by coherence
-        angle_dev_weighted = (angle_dev * ori) / np.nanmean(ori)     # no angle values anymore (stretched due weights) but the mean later is again an angle
-        orientation_dev_weighted_01 =  ((orientation_dev_01 * ori) / np.nanmean(ori)) 
-        orientation_dev_weighted = -(2  *orientation_dev_weighted_01 - 1)
-        
-
+        if min_dist:
+            angle_dev[distance<min_dist] = np.nan
+            ori[distance<min_dist] = np.nan   
+            angle[distance<max_dist] = np.nan # also for angular evaluation
+            
+            
         # weighting by coherence and image intensity
         im_fiber_g = im_fiber_g[edge:-edge,edge:-edge]
         # could also use non filtered image
@@ -366,14 +402,18 @@ def StuctureAnalysisMain(fiber_list,
         # use a threshold in the intensity image// only coherence and orientation vectors
         # corresponding to pixels in the intesity iamage above a threshold are considered.
         weight_image = gaussian(im_fiber_g,sigma=15)
+
+        # construct weighted array so that the mean value of these arrays later
+        # result in the weighted average of these
+        # weight by coherency
+        angle_dev_weighted = (angle_dev * ori) / np.nanmean(ori)
+        orientation_dev_weighted = (orientation_dev * ori) / np.nanmean(ori)
+        # weight by coherency & intensity
         angle_dev_weighted2 = (angle_dev_weighted *weight_image) / np.nanmean(weight_image)
-        orientation_dev_weighted2_01 = (orientation_dev_01 *weight_image*ori) / np.nanmean(weight_image*ori)
-        orientation_dev_weighted2 =  -(2 * orientation_dev_weighted2_01 - 1)
-        
-        # also weighting the coherency like this
+        orientation_dev_weighted2 = (orientation_dev *weight_image*ori) / np.nanmean(weight_image*ori)
+        # weighting coherency by intensity
         ori_weight2 = (ori * weight_image) / np.nanmean(weight_image)
-        
-     
+          
         # GRADIENT towards center   
         grad_y = np.gradient(im_fiber_g, axis=0)
         grad_x = np.gradient(im_fiber_g, axis=1)
@@ -394,9 +434,7 @@ def StuctureAnalysisMain(fiber_list,
         alpha_dev_total1 = np.nanmean(angle_dev[(~segmention["mask"][edge:-edge,edge:-edge])])
         alpha_dev_total2 = np.nanmean(angle_dev_weighted[(~segmention["mask"][edge:-edge, edge:-edge])])
         alpha_dev_total3 = np.nanmean(angle_dev_weighted2[(~segmention["mask"][edge:-edge, edge:-edge])])
-        # cos_dev_total1 = np.nanmean(np.cos(2*angle_dev[(~segmention["mask"][edge:-edge, edge:-edge])]*np.pi/180))
-        # cos_dev_total2 = np.nanmean(np.cos(2*angle_dev_weighted[(~segmention["mask"][edge:-edge, edge:-edge])]*np.pi/180))
-        # cos_dev_total3 = np.nanmean(np.cos(2*angle_dev_weighted2[(~segmention["mask"][edge:-edge, edge:-edge])]*np.pi/180))   
+
         cos_dev_total1 = np.nanmean(orientation_dev[(~segmention["mask"][edge:-edge,edge:-edge])   ])
         cos_dev_total2 = np.nanmean(orientation_dev_weighted[(~segmention["mask"][edge:-edge,edge:-edge])     ])
         cos_dev_total3 = np.nanmean(orientation_dev_weighted2[(~segmention["mask"][edge:-edge,edge:-edge])     ])
@@ -563,59 +601,32 @@ def StuctureAnalysisMain(fiber_list,
         excel_distance =  pd.DataFrame.from_dict(results_distance)
         excel_distance.to_excel(os.path.join(out_list[n],"results_distance.xlsx"))
         
-      
-        # Halflife values - Leave for now..
-        # # Calculate value where ntensity drops 25%
-        # distintdrop = np.abs(np.array(results_distance['Intensity Norm (individual)'])-0.75)
-        # # distance where int  drops   to 75% 
-        # halflife_int =  midofshells[np.where(distintdrop  == np.nanmin(distintdrop))[1]]
-        # # if decrease is not within range (minimum equals last value) then set to nan
-        # if halflife_int == midofshells[-1]:
-        #     halflife_int = np.nan
-        # # # Calculate value where orientation drops to 75% within maxorientation(min) to 45° (random) range 
-        # # difference to 45 degree instead of min-max range    
-        # # calculate halflife of maximal orientation over distance
-        # # difference to 45 degree for all
-        # diffdist = np.array(dist_angle_individ)-45
-        # # maximal orientation
-        # diffmax = np.nanmin(diffdist)
-        # diffmax_pos = np.where(diffmax==diffdist)[0][0]
-        # # difference  angle drops to 75% 
-        # diff2 = np.abs(diffdist-(0.75*diffmax))
-        # diff2[:diffmax_pos] = np.nan    # only look at distances on the right side /further out 
-        # halflife_ori =  midofshells[np.where(diff2 == np.nanmin(diff2))]    
-        # # if decrease is not within range (minimum equals last value) then set to nan
-        # if halflife_ori == midofshells[-1]:
-        #     halflife_ori = np.nan
-            # try:
-        #     np.savetxt(os.path.join(out_list[n],"meanangle_within10shells.txt"), [dist_angle_accum[9]]) 
-        # except:
-        #     pass
+
     
         if SaveNumpy:
             #create output folder if not existing
-            numpy_out = os.path.join(out_list[n], r"NumpyArrays" )
+            numpy_out = os.path.join(out_list[n], "NumpyArrays" )
+            print (numpy_out)
             if not os.path.exists(numpy_out):
                 os.makedirs(numpy_out)
                 
             np.save(os.path.join(numpy_out, "segmention.npy" ),segmention)
-            np.save(os.path.join(numpy_out, "AngleMap.npy" ),angle_dev )    
-            np.save(os.path.join(numpy_out, "AngleMap(weight_int).npy" ),angle_dev_weighted)    
-            np.save(os.path.join(numpy_out, "AngleMap(weight_int_coh).npy"),angle_dev_weighted2 )    
+            np.save(os.path.join(numpy_out, "AngleDeviationMap.npy" ),angle_dev )    
+            #np.save(os.path.join(numpy_out, "AngleMap(weight_int).npy" ),angle_dev_weighted)    
+            np.save(os.path.join(numpy_out, "AngleDeviationMap(weight_int_coh).npy"),angle_dev_weighted2 )    
+            np.save(os.path.join(numpy_out, "AngleMap_NoReference.npy"), angle_no_reference )  
             np.save(os.path.join(numpy_out, "OrientationMap.npy" ),orientation_dev )    
-            np.save(os.path.join(numpy_out, "OrientationMap_weight_int.npy" ),orientation_dev_weighted)    
+            #np.save(os.path.join(numpy_out, "OrientationMap_weight_int.npy" ),orientation_dev_weighted)    
             np.save(os.path.join(numpy_out, "OrientationMap_weight_intcoh.npy" ),orientation_dev_weighted2 )    
             np.save(os.path.join(numpy_out, "FiberImageCrop.npy" ),normalize(im_fiber_n[edge:-edge,edge:-edge]) )      
             np.save(os.path.join(numpy_out, "CoherencyMap.npy" ),ori )  
-            np.save(os.path.join(numpy_out, "CoherencyMap(weighted_int).npy" ),ori_weight2)  
+            #np.save(os.path.join(numpy_out, "CoherencyMap(weighted_int).npy" ),ori_weight2)  
             np.save(os.path.join(numpy_out, "Vector_min_ax0.npy"),min_evec[:,:,0])  
             np.save(os.path.join(numpy_out, "Vector_min_ax1.npy"),min_evec[:,:,1])   
-            np.save(os.path.join(numpy_out, "mask_surface_shells.npy"),mask_shells['Mask_shell'])                                                                                   
-            np.save(os.path.join(numpy_out, "mask_spherical_shells.npy"),mask_shells['Mask_shell_center'])   
-                                                           
-        
-    
-    
+            #np.save(os.path.join(numpy_out, "mask_surface_shells.npy"),mask_shells['Mask_shell'])                                                                                   
+            #np.save(os.path.join(numpy_out, "mask_spherical_shells.npy"),mask_shells['Mask_shell_center'])   
+   
+
         """
         Plott results
         """
@@ -623,55 +634,103 @@ def StuctureAnalysisMain(fiber_list,
         if plotting:
             #create output folder if not existing
             figures = os.path.join(out_list[n],"Figures")
+            print (figures)
             if not os.path.exists(figures):
                 os.makedirs(figures)
-    
+            
+            plot_angle_dev(angle_map = orientation_dev,   vmin=-1,vmax=1,
+                            vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
+                            path_png= os.path.join(figures,"Orientation.png"),label="Orientation",dpi=dpi,cmap="coolwarm")
             # plot orientation and angle deviation maps together with orientation structure 
-            plot_angle_dev(angle_map = angle_dev, 
-                           vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
-                           path_png= os.path.join(figures,"Angle_deviation.png"),label="Angle Deviation",dpi=dpi,cmap="viridis_r")
-            plot_angle_dev(angle_map = angle_dev_weighted2, 
-                           vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
-                           path_png= os.path.join(figures,"Angle_deviation_weighted.png"),label="Angle Deviation",dpi=dpi,cmap="viridis_r")
-            plot_angle_dev(angle_map = orientation_dev_weighted2 ,  
-                           vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
-                           path_png= os.path.join(figures,"Orientation_weighted.png"),label="Orientation",dpi=dpi,cmap="viridis")
-            plot_angle_dev(angle_map = orientation_dev,  
-                           vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
-                           path_png= os.path.join(figures,"Orientation.png"),label="Orientation",dpi=dpi,cmap="viridis")
-            plt.close("all") 
-            # pure coherency and pure orientation
-            plot_coherency(ori,path_png= os.path.join(figures,"coherency_noquiver.png"))
-            plot_coherency(orientation_dev_weighted2,
-                           path_png= os.path.join(figures,"Orientation_weighted_noquiver.png"),
-                           label="Orientation",dpi=dpi) 
+            # plot_angle_dev(angle_map = angle_dev, vmin=0,vmax=90,
+            #                vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
+            #                path_png= os.path.join(figures,"Angle_deviation.png"),label="Angle Deviation",dpi=dpi,cmap="viridis_r")
+           
+            # # do not show the weighted ones here, as only the mean has the same range again and here angles can be smaller/large 
+            # plot_angle_dev(angle_map = angle_dev_weighted2, 
+            #                vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
+            #                path_png= os.path.join(figures,"Angle_deviation_weighted.png"),label="Angle Deviation",dpi=dpi,cmap="viridis_r")
+            #  plot_angle_dev(angle_map = orientation_dev_weighted2 ,  
+            #                vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
+            #                path_png= os.path.join(figures,"Orientation_weighted.png"),label="Orientation",dpi=dpi,cmap="viridis") 
+        
+            # # pure coherency and pure orientation
+            # plot_coherency(ori,path_png= os.path.join(figures,"coherency_noquiver.png"),
+            #                label="Coherency",vmin=0,vmax=1,cmap="turbo",dpi=dpi)
+            # plot_coherency(orientation_dev,
+            #                path_png= os.path.join(figures,"Orientation_noquiver.png"),
+            #                label="Orientation",vmin=-1,vmax=1,cmap="coolwarm",dpi=dpi) 
+
+            
+            ### more fancy overlay plot of cell & fiber & orientation (notweighted)
+            plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                               im_cell_n[edge:-edge,edge:-edge],
+                               orientation_dev, cmap_angle="coolwarm",
+                               path_png= os.path.join(figures,"Orientation_overlay.png"),                       
+                               label="Orientation",dpi=dpi,
+                               # ,cmap_cell="Greys_r",cmap_fiber="Greys_r", ### use default values here
+                               # cmap_angle="viridis", alpha_ori =0.8,  alpha_cell = 0.4, alpha_fiber = 0.4,
+                                omin=-1, omax=1,scale=scale)
+            
+            plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                               im_cell_n[edge:-edge,edge:-edge],
+                               ori, cmap_angle="turbo",
+                               path_png= os.path.join(figures,"Coherency_overlay.png"),                       
+                               label="Coherency",dpi=dpi,
+                               # ,cmap_cell="Greys_r",cmap_fiber="Greys_r", ### use default values here
+                               # cmap_angle="viridis", alpha_ori =0.8,  alpha_cell = 0.4, alpha_fiber = 0.4,
+                                omin=0, omax=1,scale=scale)
+           
+            plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                               im_cell_n[edge:-edge,edge:-edge],
+                               angle_dev, cmap_angle="viridis_r",
+                               path_png= os.path.join(figures,"Angle_Deviation_overlay.png"),                       
+                               label="Angle Deviation",dpi=dpi,
+                               # ,cmap_cell="Greys_r",cmap_fiber="Greys_r", ### use default values here
+                               # cmap_angle="viridis", alpha_ori =0.8,  alpha_cell = 0.4, alpha_fiber = 0.4,
+                                omin=0, omax=90,scale=scale)
+          
+            plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                               im_cell_n[edge:-edge,edge:-edge],
+                               angle_no_reference, cmap_angle="gist_rainbow",
+                               path_png= os.path.join(figures,"Angle_NoReference_overlay.png"),                       
+                               label="Angle (no reference)",dpi=dpi,
+                               # ,cmap_cell="Greys_r",cmap_fiber="Greys_r", ### use default values here
+                               # cmap_angle="viridis", alpha_ori =0.8,  alpha_cell = 0.4, alpha_fiber = 0.4,
+                               omin=-180, omax=180,
+                               scale=scale)    
+            
+  
             plt.close("all") 
-            # Polar plots        
-            plot_polar(results_angle['Angles Plotting'], results_angle['Coherency (weighted by intensity)'],
-                       path_png= os.path.join(figures,"polar_coherency_weighted.png"), label = "Coherency (weighted)",dpi=dpi)
+        
             
-                    
+            # Polar plots              
             plot_polar(results_angle['Angles Plotting'], results_angle['Coherency (weighted by intensity)'],
                        path_png= os.path.join(figures,"polar_coherency_double.png"), label = "Coherency (weighted)",
-                       something2 = results_angle['Coherency'], label2 = "Coherency",dpi=dpi)
-            
-            plot_polar(results_angle['Angles Plotting'], results_angle['Mean Intensity'],
-                       path_png= os.path.join(figures,"polar_intensity.png"), label = "Mean Intensity",dpi=dpi)
+                       something2 = results_angle['Coherency'], label2 = "Coherency",dpi=dpi, vmin=0,vmax=1)
             
             plot_polar(results_angle['Angles Plotting'], results_angle['Orientation (weighted by intensity and coherency)'],
-                               path_png= os.path.join(figures,"Orientation_weighted_polar.png"), label = "Orientation",dpi=dpi)
+                       path_png= os.path.join(figures,"polar_orientation_double.png"), label = "Orientation (weighted)",
+                       something2 = results_angle['Orientation'], label2 = "Orientation",dpi=dpi, vmin=-1,vmax=1)
             
-            plot_polar(results_angle['Angles Plotting'], results_angle['Orientation'],
-                               path_png= os.path.join(figures,"Orientation_polar.png"), label = "Orientation",dpi=dpi)
-            plt.close("all") 
+           # plot_polar(results_angle['Angles Plotting'], results_angle['Coherency (weighted by intensity)'],
+           #            path_png= os.path.join(figures,"polar_coherency_weighted.png"), label = "Coherency (weighted)",dpi=dpi) 
+            
+            # plot_polar(results_angle['Angles Plotting'], results_angle['Mean Intensity'],
+            #            path_png= os.path.join(figures,"polar_intensity.png"), label = "Mean Intensity",dpi=dpi)
+            
+            # plot_polar(results_angle['Angles Plotting'], results_angle['Orientation (weighted by intensity and coherency)'],
+            #                    path_png= os.path.join(figures,"Orientation_weighted_polar.png"), label = "Orientation",dpi=dpi)
+            
+            # plot_polar(results_angle['Angles Plotting'], results_angle['Orientation'],
+            #                    path_png= os.path.join(figures,"Orientation_polar.png"), label = "Orientation",dpi=dpi)
+            # quiver plots with center overlay   
+            # quiv_coherency_center(vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
+            #                  center0=center_small[0],center1 = center_small[1],
+            #                path_png= os.path.join(figures,"quiv_coherency_center.png"),dpi=dpi )
+
             # summarizing triple plot
             plot_triple(results_angle,results_total , path_png= os.path.join(figures,"Triple_plot.png") ,dpi=dpi)
-       
-            # quiver plots with center overlay   
-            quiv_coherency_center(vec0=min_evec[:,:,0] ,vec1=min_evec[:,:,1] ,coherency_map=ori,
-                             center0=center_small[0],center1 = center_small[1],
-                           path_png= os.path.join(figures,"quiv_coherency_center.png"),dpi=dpi )
-            plt.close("all") 
             # image fiber + segmention
             plot_fiber_seg(fiber_image=normalize(im_fiber_n[edge:-edge,edge:-edge]) ,
                            c0=center_small[0],c1=center_small[1],
@@ -685,11 +744,12 @@ def StuctureAnalysisMain(fiber_list,
                            segmention=segmention["mask"][edge:-edge,edge:-edge], 
                            path_png=os.path.join(figures,"overlay.png"),dpi=dpi ,scale=scale)
             
-            plot_overlay(fiber_image=normalize(im_fiber_n[edge:-edge,edge:-edge]) ,
-                           c0=center_small[0],c1=center_small[1], vec0=min_evec[:,:,0],
-                           vec1=min_evec[:,:,1], coherency_map=ori,show_n=10,
-                           segmention=segmention["mask"][edge:-edge,edge:-edge], 
-                           path_png=os.path.join(figures,"overlay2.png"),dpi=dpi ,scale=scale)
+            # plot_overlay(fiber_image=normalize(im_fiber_n[edge:-edge,edge:-edge]) ,
+            #                c0=center_small[0],c1=center_small[1], vec0=min_evec[:,:,0],
+            #                vec1=min_evec[:,:,1], coherency_map=ori,show_n=10,
+            #                segmention=segmention["mask"][edge:-edge,edge:-edge], 
+            #                path_png=os.path.join(figures,"overlay2.png"),dpi=dpi ,scale=scale)
+
             plt.close("all") 
             ### DISTANCE PLOTS
             # plot shells - deactived as it consumes a lot of time
@@ -701,12 +761,12 @@ def StuctureAnalysisMain(fiber_list,
         
             plot_distance(results_distance,string_plot = "Intensity Norm (individual)",
               path_png=os.path.join(figures,"Intensity_distance.png"),dpi=dpi)
-            plt.close("all") 
+
+            
             # save raw cell image   
             plot_cell(im_cell_n, path_png=os.path.join(figures,"cell-raw.png"),  scale=scale, dpi=dpi)
 
-            plt.close("all")    
-            
+            plt.close("all")         
 
     return
 
@@ -733,10 +793,10 @@ def SummarizeResultsTotal(data, output_folder= None):
                'Overall weighted Oriantation (std all cells)': []} 
     
     for i, path in enumerate(list_total):
-       results_total_combined['Orientation (weighted by coherency)'].append(float(pd.read_excel(list_total[i])['Orientation (weighted by coherency)']))
-       results_total_combined['Orientation (weighted by intensity and coherency)'].append(float(pd.read_excel(list_total[i])['Orientation (weighted by intensity and coherency)']))
-       results_total_combined['Mean Angle (weighted by coherency)'].append(float(pd.read_excel(list_total[i])['Mean Angle (weighted by coherency)']))
-       results_total_combined['Mean Angle (weighted by intensity and coherency)'].append(float(pd.read_excel(list_total[i])['Mean Angle (weighted by intensity and coherency)']))
+       results_total_combined['Orientation (weighted by coherency)'].append(float(pd.read_excel(list_total[i])['Orientation (weighted by coherency)'][0]))
+       results_total_combined['Orientation (weighted by intensity and coherency)'].append(float(pd.read_excel(list_total[i])['Orientation (weighted by intensity and coherency)'][0]))
+       results_total_combined['Mean Angle (weighted by coherency)'].append(float(pd.read_excel(list_total[i])['Mean Angle (weighted by coherency)'][0]))
+       results_total_combined['Mean Angle (weighted by intensity and coherency)'].append(float(pd.read_excel(list_total[i])['Mean Angle (weighted by intensity and coherency)'][0]))
        results_total_combined['Path'].append(str(list_total[i]))
        
     ovreall_orientation = np.nanmean(results_total_combined['Orientation (weighted by intensity and coherency)'])