CompactionAnalyzer 1.0.1__tar.gz → 1.0.7__tar.gz

{CompactionAnalyzer-1.0.1 → compactionanalyzer-1.0.7}/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):
@@ -124,7 +146,10 @@ def segment_cell(img, thres=1, seg_gaus1 = 0.5, seg_gaus2=100, seg_iter=1,show_s
     height = img.shape[0]
     width = img.shape[1]
     
-    
+    ## if 3 channels convert to grey  
+    if len(img.shape) == 3 :      
+        img = color.rgb2gray(img)
+
     # local gaussian (or single gaussian if gaus2 == None)  
     if seg_gaus2 is not None:
         img = np.abs(gaussian(img, sigma=seg_gaus1) - gaussian(img, sigma=seg_gaus2))
@@ -195,6 +220,24 @@ def segment_cell(img, thres=1, seg_gaus1 = 0.5, seg_gaus2=100, seg_iter=1,show_s
     return {'mask': mask, 'radius': radius, 'centroid': (cx, cy)}
 
 
+def create_centered_circle(image_shape):
+    # Extract the height and width of the image
+    height, width = image_shape[:2]
+    # Calculate the center of the image
+    center_y, center_x = height // 2, width // 2
+    # Calculate the radius of the circle (1/4 of the image height or width)
+    radius = min(height, width) // 10
+    # Create a 2D array of zeros (background)
+    circle_array = np.zeros((height, width), dtype=int)
+    # Iterate over each point in the 2D array
+    for y in range(height):
+        for x in range(width):
+            # Calculate the distance from the center
+            distance = np.sqrt((y - center_y) ** 2 + (x - center_x) ** 2)
+            # If the distance is less than or equal to the radius, set it to 1 (circle)
+            if distance <= radius:
+                circle_array[y, x] = 1
+    return circle_array
 
 
 def StuctureAnalysisMain(fiber_list,
@@ -204,10 +247,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
@@ -216,15 +260,24 @@ def StuctureAnalysisMain(fiber_list,
                          manual_segmention = False    , # segmentation of mask by manual clicking the cell outline
                          plotting = True     ,          # creates and saves individual figures additionally to the excel files 
                          dpi = 200      ,               # resolution of figures 
-                         SaveNumpy = False       ,      # saves numpy arrays for later analysis - can create large data files
+                         SaveNumpy = True  ,            # saves numpy arrays for later analysis
+                         SaveExcel = True  ,            # saves Excel files for later analysis
                          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    
+
+                         
+                         mode_saenopy=False):           # only used for the Saenopy Version to return data files directly after single run   
+    
+    
+    
     """
     Main analysis
     
@@ -239,8 +292,16 @@ def StuctureAnalysisMain(fiber_list,
     None.
 
     """
-    plt.ioff()
-   # plt.ion()
+    # plt.ioff()
+    # plt.ion()
+    
+    # if no cell images are specified we conduct the analyis on the full image 
+    # for this, we create dummy images of an artificial cell and set ignore_cell_outline to True
+    # Might be usefull to look at quantities such as fiber coherency or angle towards x-axis 
+    if cell_list == None:
+        ignore_cell_outline= True
+        dummy_cell = create_centered_circle(imageio.v2.imread(fiber_list[0]).shape)
+
     
     # if not specified use 7um for tensor analysis and 5um shells
     if not sigma_tensor:
@@ -268,30 +329,34 @@ 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]}
                     }  
         with open(os.path.join(out_list[n],"parameters.yml"), 'w') as yaml_file:
             yaml.dump(dict_file, yaml_file, default_flow_style=False)
-  
             
-        # load images
-        im_cell  = imageio.imread(cell_list[n])  #color.rgb2gray(..)
-        im_fiber = imageio.imread(fiber_list[n])   #color.rgb2gray()
+        # load images      
+        im_fiber = imageio.v2.imread(fiber_list[n])     #color.rgb2gray()
+        if cell_list == None:
+            im_cell = dummy_cell
+        else:
+            im_cell  = imageio.v2.imread(cell_list[n])
+        
         
         ## if 3 channels convert to grey  
-        if len(im_cell.shape) == 3 :
+        if len(im_cell.shape) == 3 :      
             im_cell = color.rgb2gray(im_cell)
         if len(im_fiber.shape) == 3 :
-            im_fiber = color.rgb2gray(im_fiber)    
-        
+            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 +373,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 +409,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))%180)-90   # -90 to +90° towards x-axis
+
+        
         """
         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 +442,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 +474,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])     ])
@@ -420,7 +498,8 @@ def StuctureAnalysisMain(fiber_list,
         results_total['Orientation (weighted by intensity and coherency)'].append(cos_dev_total3)
         
         excel_total = pd.DataFrame.from_dict(results_total)
-        excel_total.to_excel(os.path.join(out_list[n],"results_total.xlsx"))
+        if SaveExcel:
+            excel_total.to_excel(os.path.join(out_list[n],"results_total.xlsx"))
     
     
         """
@@ -475,14 +554,18 @@ def StuctureAnalysisMain(fiber_list,
 
         # create excel sheet with results for angle analysis       
         excel_angles= pd.DataFrame.from_dict(results_angle)
-        excel_angles.to_excel(os.path.join(out_list[n],"results_angles.xlsx"))
-    
+        if SaveExcel:
+            excel_angles.to_excel(os.path.join(out_list[n],"results_angles.xlsx"))
     
+   
         """
         Distance Evaluation
         """
         
-         # initialize result dictionary
+        
+         #  def distance_analysis(shells,shell_width,dist_surface,scale,angle_dev, ori, orientation_dev, weight_image,im_fiber_g):
+
+          # initialize result dictionary
         results_distance = {'Shell_mid (px)': [], 'Shell_mid (µm)': [], 'Intensity (accumulated)': [], 
                             'Intensity (individual)': [], 'Intensity Norm (individual)': [],
                             'Intensity Norm (accumulated)': [],  'Angle (accumulated)': [],  'Angle (individual)': [],  'Angle (individual-weightInt)': [], 
@@ -494,7 +577,7 @@ def StuctureAnalysisMain(fiber_list,
                             'Angle disttocenter (accumulated)': [],  'Angle disttocenter (individual)': [],  
                             'Orientation disttocenter (accumulated)': [], 'Orientation disttocenter (individual)': [], 
                             'Angle disttocenter (individual)': []            
-                         }      
+                          }      
     
         mask_shells = {'Mask_shell': [], 'Mask_shell_center': [] } 
         # shell distances
@@ -527,7 +610,7 @@ def StuctureAnalysisMain(fiber_list,
                 results_distance['Orientation (individual-weightInt)'].append(np.nanmean(orientation_dev[mask_shell]*ori[mask_shell]*weight_image[mask_shell]/np.nanmean(ori[mask_shell]*weight_image[mask_shell]) ))    
                
         
-               # mean intensity
+                # mean intensity
                 results_distance['Intensity (accumulated)'].append(np.nanmean(im_fiber_g[mask_shell_lower]))          # accumulation of lower shells
                 results_distance['Intensity (individual)'].append(np.nanmean(im_fiber_g[mask_shell])  )    # exclusively in certain shell
       
@@ -561,135 +644,161 @@ def StuctureAnalysisMain(fiber_list,
         results_distance['Intensity Norm disttocenter (accumulated)'].extend(list(norm_accum_int_c) )    
         # create excel sheet with results for angle analysis       
         excel_distance =  pd.DataFrame.from_dict(results_distance)
-        excel_distance.to_excel(os.path.join(out_list[n],"results_distance.xlsx"))
+        if SaveExcel:
+            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 )    
+            # save data array all with the size of the evaluated arrays
+            # that are "edge" - pixels smaller to get rid of boundary artefacts
+            np.save(os.path.join(numpy_out, "segmention.npy" ),segmention["mask"][edge:-edge,edge:-edge])
+            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, "center.npy"),center_small)  
+            #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'])   
+       
+            # check the shapes --> everything is the same format
+            # print(segmention["mask"][edge:-edge,edge:-edge].shape)    
+            # print(orientation_dev.shape)   
+            # print(normalize(im_fiber_n[edge:-edge,edge:-edge]).shape)    
+            # print(angle_no_reference.shape)   
+   
+
         """
-        Plott results
+        Plotting results
         """
         
         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 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 = 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")
+          
+
+
+            if cell_list == None:
+                plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                                   None,
+                                   angle_no_reference, cmap_angle="gist_rainbow",
+                                   path_png= os.path.join(figures,"Angle_NoReference_overlay_nocell.png"),                       
+                                   label="Angle (x-axis)",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=-90, omax=90,
+                                   scale=scale)    
+                plot_fancy_overlay(im_fiber_n[edge:-edge,edge:-edge], 
+                                   None,
+                                   ori, cmap_angle="turbo",
+                                   path_png= os.path.join(figures,"Coherency_overlay_nocell.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],
+                                   orientation_dev, cmap_angle="coolwarm",
+                                   path_png= os.path.join(figures,"Orientation_overlay.png"),                       
+                                   label="Orientation",dpi=dpi,
+                                    omin=-1, omax=1,scale=scale)
+            
+            else:
+                ### 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 (x-axis)",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=-90, omax=90,
+                                   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") 
             # 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],
-                           segmention=segmention["mask"][edge:-edge,edge:-edge], 
-                           path_png=os.path.join(figures,"fiber_segemention.png"),dpi=dpi,scale=scale )
-        
-            # plot overlaywith fiber image 
-            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=15,
-                           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)
+                
+            if cell_list is not None:
+                
+                # image fiber + segmention
+                plot_fiber_seg(fiber_image=normalize(im_fiber_n[edge:-edge,edge:-edge]) ,
+                               c0=center_small[0],c1=center_small[1],
+                               segmention=segmention["mask"][edge:-edge,edge:-edge], 
+                               path_png=os.path.join(figures,"fiber_celloutline.png"),dpi=dpi,scale=scale )  
+                # plot overlaywith fiber image 
+                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=15,
+                               segmention=segmention["mask"][edge:-edge,edge:-edge], 
+                               path_png=os.path.join(figures,"fiber_cell_structure.png"),dpi=dpi ,scale=scale)
+            else:
+                # plot overlaywith fiber image 
+                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=15,
+                               segmention=None, 
+                               path_png=os.path.join(figures,"fiber_structure.png"),dpi=dpi ,scale=scale)
+                
+          
             plt.close("all") 
             ### DISTANCE PLOTS
             # plot shells - deactived as it consumes a lot of time
@@ -701,13 +810,34 @@ 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)
+            plot_cell(normalize(im_fiber_n[edge:-edge,edge:-edge]), path_png=os.path.join(figures,"fiber-raw.png"),  scale=scale, dpi=dpi)
 
-            plt.close("all")    
+            plt.close("all")      
+            
+        if mode_saenopy == True: # only evaluates a single item at each call and returns the arrays
+             return angle_no_reference, orientation_dev, ori, min_evec, excel_total, excel_angles, excel_distance
+            
+            # np.save(os.path.join(numpy_out, "segmention.npy" ),segmention["mask"][edge:-edge,edge:-edge])
+            # 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_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, "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, "center.npy"),center_small)  
+            
+            
             
-
     return
 
 
@@ -733,10 +863,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)'])