CompactionAnalyzer 1.0.3__tar.gz → 1.0.5__tar.gz

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

@@ -146,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))
@@ -217,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,
@@ -239,7 +260,8 @@ 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
@@ -249,7 +271,13 @@ def StuctureAnalysisMain(fiber_list,
                          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
-                         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    
+                         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
     
@@ -264,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:
@@ -300,17 +336,21 @@ def StuctureAnalysisMain(fiber_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.v2.imread(cell_list[n])  #color.rgb2gray(..)
-        im_fiber = imageio.v2.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)
@@ -370,8 +410,8 @@ def StuctureAnalysisMain(fiber_list,
         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)
-               
+        angle_no_reference = np.abs(np.arctan2(min_evec[:,:,0],min_evec[:,:,1])*360/(2*np.pi))-90   # -90 to +90° towards x-axis
+                     
         
         """
         total image analysis
@@ -458,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"))
     
     
         """
@@ -513,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)': [], 
@@ -532,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
@@ -565,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
       
@@ -599,7 +644,8 @@ 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"))
         
 
     
@@ -609,8 +655,9 @@ def StuctureAnalysisMain(fiber_list,
             print (numpy_out)
             if not os.path.exists(numpy_out):
                 os.makedirs(numpy_out)
-                
-            np.save(os.path.join(numpy_out, "segmention.npy" ),segmention)
+            # 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 )    
@@ -623,8 +670,15 @@ def StuctureAnalysisMain(fiber_list,
             #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)  
             #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)   
    
 
         """
@@ -641,68 +695,75 @@ def StuctureAnalysisMain(fiber_list,
             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, 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) 
+          
 
+
+            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)
             
-            ### 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)    
+            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)'],
@@ -713,43 +774,31 @@ def StuctureAnalysisMain(fiber_list,
                        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['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)
-            # 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
@@ -765,9 +814,12 @@ def StuctureAnalysisMain(fiber_list,
             
             # 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
     return
 
 

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/CompactionAnalyzer/plotting.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 import matplotlib
 from matplotlib_scalebar.scalebar import ScaleBar
 import warnings
-matplotlib.pyplot.switch_backend("agg")
+#matplotlib.pyplot.switch_backend("agg")
 
 def scale_for_quiver(ar1, ar2, dims, scale_ratio=0.2, return_scale=False):
     scale = scale_ratio * np.max(dims) / np.nanmax(np.sqrt((ar1) ** 2 + (ar2) ** 2))
@@ -161,7 +161,8 @@ def plot_fancy_overlay(fiber, cell, field,path_png,label="field",dpi=300,cmap_ce
     fig =plt.figure()
     plt.imshow(field,cmap=cmap_angle,vmin=omin,vmax=omax,alpha=alpha_ori);cbar =plt.colorbar()
     plt.imshow(fiber, cmap=cmap_fiber,alpha=alpha_fiber) 
-    plt.imshow(cell, cmap=cmap_cell,alpha=alpha_cell) 
+    if cell is not None:
+        plt.imshow(cell, cmap=cmap_cell,alpha=alpha_cell) 
     plt.axis('off');
     cbar.set_label(label,fontsize=12)
     if scale is not None:
@@ -242,7 +243,8 @@ def plot_fiber_seg(fiber_image,c0,c1,segmention, path_png,dpi=200, scale=None ):
     cmap.set_over('k', alpha=1)
     # plot mask and center
     plt.imshow(fiber_image, origin="upper")
-    plt.imshow(segmention, cmap=cmap, norm = my_norm, origin="upper")
+    if segmention is not None:
+        plt.imshow(segmention, cmap=cmap, norm = my_norm, origin="upper")
     plt.scatter(c0,c1, c= "w");plt.axis('off');
     if scale is not None:
         scalebar = ScaleBar(scale, "um", length_fraction=0.1, location="lower right", box_alpha=0 , 
@@ -266,8 +268,9 @@ def plot_overlay(fiber_image , c0,c1, vec0,vec1, coherency_map,
             # plot mask and center
             show_quiver (vec0 * coherency_map, vec1 * coherency_map, filter=[f, show_n],alpha=0 , scale_ratio=0.08,width=0.002, plot_cbar=False, cbar_str="coherency", cmap="viridis")
             plt.imshow(fiber_image, origin="upper")
-            plt.imshow(segmention, cmap=cmap, norm = my_norm, origin="upper", zorder=100)
-            plt.scatter(c0,c1, c= "w", zorder=200)
+            if segmention is not None:
+                plt.imshow(segmention, cmap=cmap, norm = my_norm, origin="upper", zorder=100)
+                plt.scatter(c0,c1, c= "w", zorder=200)
             if scale is not None:
                 scalebar = ScaleBar(scale, "um", length_fraction=0.1, location="lower right", box_alpha=0 , 
                             color="k")
@@ -304,7 +307,7 @@ def plot_distance(results_distance,path_png,string_plot = "Orientation (individu
     return fig
            
 def plot_cell(im_cell_n,  path_png,scale=None,dpi=200):
-        fig = plt.figure(); plt.imshow(im_cell_n);plt.axis("off"),plt.tight_layout()
+        fig = plt.figure(); plt.imshow(im_cell_n, cmap="viridis");plt.axis("off"),plt.tight_layout()
         if scale is not None:
             scalebar = ScaleBar(scale, "um", length_fraction=0.1, location="lower right", box_alpha=0 , 
                         color="k")

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/CompactionAnalyzer/utilities.py

@@ -29,16 +29,18 @@ def generate_lists(fiber_list_string, cell_list_string, output_main = "Output"):
 
     # read in images (must be in same order)
     fiber_list = natsorted(glob.glob(fiber_list_string))  
-    cell_list = natsorted(glob.glob(cell_list_string))   #check that order is same to fiber
+    if cell_list_string is not None:
+        cell_list = natsorted(glob.glob(cell_list_string))   #check that order is same to fiber
+    else:
+        cell_list = None
     # get base path (before * in glob - even works without any *)
-    base = os.path.split(cell_list_string[:cell_list_string.find("*")])[0]
+    base = os.path.split(fiber_list_string[:fiber_list_string.find("*")])[0]
     # get the rest of the path
-    rest_paths =[os.path.split(os.path.relpath(p, base))[0] for p in (cell_list)]
+    rest_paths =[os.path.split(os.path.relpath(p, base))[0] for p in (fiber_list)]
     # get the file name
-    names = [os.path.splitext(os.path.split(p)[1])[0] for p in cell_list]
+    names = [os.path.splitext(os.path.split(p)[1])[0] for p in fiber_list]
     # put together accordingly in the output_main folder
     out_list = [os.path.join(output_main,rest_path, name) for name, rest_path in zip(names, rest_paths)]
-
     return fiber_list,cell_list, out_list
     
 

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/CompactionAnalyzer.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: CompactionAnalyzer
-Version: 1.0.3
-Summary: A Python package to analyze tissue compaction around cells in fiber materials
+Version: 1.0.5
+Summary: A python package to analyze matrix fiber alignment around cells (proxy for cellular forces)
 Home-page: 
 Download-URL: 
 Author: David Böhringer, Andreas Bauer

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: CompactionAnalyzer
-Version: 1.0.3
-Summary: A Python package to analyze tissue compaction around cells in fiber materials
+Version: 1.0.5
+Summary: A python package to analyze matrix fiber alignment around cells (proxy for cellular forces)
 Home-page: 
 Download-URL: 
 Author: David Böhringer, Andreas Bauer

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/README.md

@@ -16,7 +16,7 @@ Python package to quantify the tissue compaction (as a measure of the contractil
 * Evaluating the directionality of fibers towards the cell center.
 * Evaluating the increased fiber intensity around the cell.  
 
-Further, the package can be used to evaluate the strength of allignment (coherency) regardless of the allignment direction, or the allignment orientation towards the x-axis (instead of the cell center). For this, see the point "Save Nummpy Files" below.
+Further, the package can be used to evaluate the strength of allignment (coherency) regardless of the allignment direction, or the allignment orientation towards the x-axis (instead of the cell center). For this, see the point "Save Numpy Files" below.
 
 <img src="../master//docs/images/Fig1-rawtostructure.png" width="1000" />
 
@@ -47,7 +47,7 @@ CompactionAnalyzer is included within the [saenopy package](https://github.com/r
 
 
 
-## Preprint
+## Read More
 If you'd like to learn more about the mehtod, have a look at our paper:
 
 *Böhringer D, Bauer A, Moravec I, Bischof L, Kah D, Mark C, Grundy TJ, Görlach E, O'Neill GM, Budday S, Strissel PL, Strick R, Malandrino A, Gerum R, Mak M, Rausch M, Fabry B*. **Fiber alignment in 3D collagen networks as a biophysical marker for cell contractility**. Matrix Biology (2023). [doi: 10.1016/j.matbio.2023.11.004](https://www.sciencedirect.com/science/article/pii/S0945053X23001166?via%3Dihub)
@@ -109,6 +109,7 @@ segmention_method="otsu"        # use "otsu", "entropy" or "yen"  as segmentatio
 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
+ignore_cell_outline= False      # if True also values at the cell-occupied areas are included in the analysis
 ```
 
 
@@ -152,18 +153,30 @@ We receive a compromised excel sheet that returns the global analysis for all ce
 
 <img src="../master/docs/images/Fig3-combineexcel.png" width="800" />
 
-## Saving Numpy Files
+## Save Numpy Files
 
 If you want to save the angle or coherency maps for different kind of analysis, you can specify the parameter `SaveNumpy = True`. 
 Each output folder will then contain among other properties the following npy-files:
 
 <img src="../master//docs/images/npy-files-1.png" width="800" />
 
-`FiberImageCrop.npy` contains the original input fiber image resized to the size of the output analysis maps. These files have (depending on the argument `edge`) less pixels because the image edges should be excluded to avoid orientation analysis artifacts (default: 15px). `OrientationMap.npy` includes the orientation to the cell center (between -1 and 1) as explained above. `CoherencyMap.npy` can be used as a measure of anisotropy or orientation strength within the image (between 0 and 1), regardless of the specific direction of the orientation. This can be advantageous when the direction varies, such as in images containing multiple cells with stained stress fibers oriented in different directions. Quantifying the average coherence of these stress fibers in the cell occupied area can still provide insight into the strength of these fibers. 
+`FiberImageCrop.npy` contains the original input fiber image resized to the size of the output analysis maps. These files have (depending on the argument `edge`) less pixels because the image edges should be excluded to avoid orientation analysis artifacts (default: 15px). `OrientationMap.npy` includes the orientation to the cell center (between -1 and 1) as explained above. `CoherencyMap.npy` can be used as a measure of anisotropy or orientation strength within the image (between 0 and 1), regardless of the specific direction of the orientation. This can be advantageous when the direction varies, such as in images containing multiple cells with stained stress fibers oriented in different directions. Quantifying the average coherence of these stress fibers in the cell occupied area can still provide insight into the strength of the allignment. 
 
 <img src="../master//docs/images/npy-files-2.png" width="800" />
 
-`AngleDeviationMap.npy` includes the deviation of the raw angles with respect to the cell center. These angles are used to calculate the orientation map below. The raw angles with respect to the x-axis but with no respect to the cell center are included in `AngleMap_NoReference.npy`. They are calculated from the structure vectory in x- and y- direction stored in `Vector_min_ax0.npy` and `Vector_min_ax1.npy`. `segmentation.npy` contains the segmented cell mask, where no analysis is performed in the normal procedure. To compute and store all these numpy fields even in places where the cell is segmented, you can use the argument `ignore_cell_outline=True` in the analysis pipeline. This will compute these maps within the entire image. Technically, however, you still need to specify image pairs to start the analysis.
+`AngleDeviationMap.npy` includes the deviation of the raw angles with respect to the cell center. These angles are used to calculate the orientation map. The raw angles with respect to the x-axis (but with no respect to the cell center) are included in `AngleMap_NoReference.npy` (between -90 and 90 degree). They are calculated from the structure vectory in x- and y- direction stored in `Vector_min_ax1.npy` and `Vector_min_ax0.npy`. `segmentation.npy` contains the segmented cell mask, where no analysis is performed in the normal procedure. To compute and store all these numpy fields even in places where the cell is segmented, you can use the argument `ignore_cell_outline=True` in the analysis pipeline. This will compute these maps within the entire image. 
+
+
+If you want to calculate the fiber coherency `CoherencyMap.npy` or the angle towards the x-axis  `AngleMap_NoReference.npy` (between -90 and 90 degree) without an image of the cell you can start the analysis by setting `cell_list_string = None`:
+
+```python
+fiber_list, cell_list, out_list = generate_lists(fiber_list_string, None, output_main =output_folder)
+```
+
+This option will start the analysis without the second image pair of cell images and automatically compute all maps within the entire image using the `ignore_cell_outline=True` argument. The typical orientation map is calculated with respect to the image center. 
+
+<img src="../master//docs/images/npy-files-3.png" width="800" />
+
 
 ## Graphical User Interface (GUI)
 

{compactionanalyzer-1.0.3 → compactionanalyzer-1.0.5}/setup.py

@@ -4,8 +4,8 @@ from setuptools import setup
 setup(
     name='CompactionAnalyzer',
     packages=['CompactionAnalyzer'],
-    version='1.0.3',
-    description='A Python package to analyze tissue compaction around cells in fiber materials',
+    version='1.0.5',
+    description='A python package to analyze matrix fiber alignment around cells (proxy for cellular forces)',
     url='',
     download_url = '',
     author='David Böhringer, Andreas Bauer',