Delete Ambrosia.py

Ambrosia.py

@@ -1,296 +0,0 @@
-# CLASS: 
-    # pre_process_image
-    # METHODS:
-        # __init__
-            # INPUT:
-                # image_dir = (str) a full path to an image with multiple beetles and possibly a size reference circle
-                # manual_thresh_buffer (float) {optional} this is a manual way to control the binarizxing threshold. 
-                    # use this when beetles are broken up into multiple images\
-                    # inputs should range from -1 to 1. higehr vlaues include lighter colors into the blobs and lower values reduce blob size
-            # OUTPUT(ATTRIBUTES):
-                # image_dir = (str) the same directory as is given as an input to the iamge that is being processed
-                # image = (np.array) the original compound image
-                # grey_image = (np.array) the original compound image in greyscale
-                # bw_image = (np.array) the original image in binary black and white
-                # inv_bw_image = (np.array) the original image inverted black and white binary
-                # clear_inv_bw_image = (np.array) the inverted black and white binary original image with all components touching the border removed
-        # segment
-            # INPUT:
-                # cluster_num = (int) {default=2} the number of clusters used for kmeans to pick only the cluster with alrgest blobs
-                # image_edge_buffer = (int) {default=50} number of pixels to add to box borders
-            # OUTPUT(ATTRIBUTES):
-                # cluster_num = (int) the same as the input
-                # image_edge_buffer = (int) the same as the input
-                # labeled_image = (np.array) the original compound image that is labelled
-                # max_kmeans_label = (int) the label of the cluster with the largest object/blob
-                # image_selected_df = (pd.DataFrame) a dataframe with columns describing each segmented image: 
-                                                                                # 'centroid' = centre of the image
-                                                                                # 'bbox-0' = border 0
-                                                                                # 'bbox-1' = border 1
-                                                                                # 'bbox-2' = border 2
-                                                                                # 'bbox-3' = border 3
-                                                                                # 'orientation' = angle of image segment
-                                                                                # 'axis_major_length'
-                                                                                # 'axis_minor_length'
-                                                                                # 'area'
-                                                                                # 'area_filled'
-                # image_properties_df = (pd.DataFrame) similar to the image_selected_df, but inlcudes all the artefacts that are picked up
-                # col_image_lst = (list) a list with all the segmented images in color
-                # inv_bw_image_lst = (list) a list with all the segmented images in inverted binary black and white
-                # image_segment_count = (int) number of segmented images extracted from the compound image
-        # detect_outlier
-            # INPUT:
-                # None
-            # OUTPUT(ATTRIBUTES):
-                # image_array = (np.array) an array of the list of color segemented images (number of images, (R,G,B))
-                # r_ar_lst = (list) a list of arrays with flattened images red values
-                # g_ar_lst = (list) a list of arrays with flattened images green values
-                # b_ar_lst = (list) a list of arrays with flattened images blue values
-                # all_ar_lst = (list) a list of arrays with flattened images all red, green, and blue values
-                # px_dens_dist = (np.array) frequency distribution at 0-255 of all the values for each pixel
-                # corr_coef = (np.array) a square array of length equal to the number of segmented images showing the spearman correlation bewteen images
-                # corr_pval = (np.array) the pvalues associatedwith each correlation
-                # corr_coef_sum = (np.array) the sum of the correlations across each iamge compared to all others
-                # outlier_idx = (int) the index of the image with the lowest spearman correlation sum
-                # outlier_val = (float) the lowest sum correlation value
-                # outlier_col_image = (np.array) the color image of what is detected as the outlier
-                # outlier_inv_bw_image = (np.array) the inverted black on white image of the outlier segmented image
-                # outlier_bw_image = (np.array) the white on black image of the outlier segmented image
-                # image_selected_df = (pd.DataFrame) an updated dataframe that contains the circle identification data
-        # estimate_size
-            # INPUT:
-                # known_radius = (int) {default=1} the radius of the reference circle (shoudl be approximately the same size as the specimens to work best)
-                # canny_sigma = (int) {default=5} this describes how strict the cleaning border is for identifying the circle to place over the reference circle
-                # outlier_idx = (int) {default should be self.outlier_idx} change this when the circle is falsely detected
-            # OUTPUT(ATTRIBUTES):
-                # outlier_bw_image = (np.array) an updated version of the outlier iamge with a clean circle clear of artifacts
-                # outlier_idx = (int) same as the input
-                # clean_inv_bw_image_lst = (list) a list of cleaned white on black images no blobs touching hte border
-                # image_selected_df = (pd.DataFrame) an update to the dataframe of metadata containing pixel counts and relative area in mm^2 of all segmented images
-# *black and white is white on black
-
-# import requirements
-import os
-os.environ["OMP_NUM_THREADS"] = '1' #use this line on windows machines to avoid memory leaks
-import numpy as np
-import pandas as pd
-from math import ceil
-from skimage import io
-from skimage.filters import threshold_otsu
-from skimage.color import rgb2gray
-from skimage.segmentation import clear_border
-from skimage.measure import label, regionprops_table
-from skimage.transform import hough_circle, hough_circle_peaks
-from skimage.feature import canny
-from skimage.draw import disk
-from sklearn.cluster import KMeans
-from scipy.stats import spearmanr
-
-class pre_process_image:
-    # initialize image to be segmented from path
-    def __init__(self, image=None, image_dir=None, manual_thresh_buffer=0):
-        if image_dir is not None:
-            self.image_dir = image_dir.replace('\\','/') # full directory path to image
-            self.image = io.imread(image_dir) # read image from directory
-        elif image is not None:
-            self.image = image
-        else:
-            print("No image given to function")
-        self.grey_image = rgb2gray(self.image) #convert image to greyscale
-        self.bw_image = self.grey_image > threshold_otsu(self.grey_image) + manual_thresh_buffer # binarize image to be black & white
-        self.inv_bw_image = np.invert(self.bw_image) # invert black and white image
-        self.clear_inv_bw_image = clear_border(self.inv_bw_image) # remove anything touching image border
-    
-    # segment the image into smaller images
-    def segment(self, cluster_num=2, image_edge_buffer=50):
-        self.cluster_num = cluster_num
-        self.image_edge_buffer = image_edge_buffer
-        self.labeled_image = label(self.clear_inv_bw_image) #label image
-        image_properties_df = pd.DataFrame( # get the properties of each image used to segment blobs in image
-            regionprops_table(
-                self.labeled_image, 
-                properties=('centroid',
-                           'bbox',
-                           'orientation',
-                           'axis_major_length',
-                           'axis_minor_length',
-                           'area',
-                           'area_filled')
-                                    )
-                                )
-        # cluster boxes of blobs by size
-        kmean_result = KMeans(n_clusters=cluster_num, n_init='auto').fit(
-            np.array(
-                image_properties_df[['axis_major_length', 'axis_minor_length']]
-            )
-        )
-        image_properties_df['kmeans_label'] = kmean_result.labels_
-        # keep only the largest cluster (ball bearing needs to be a similar size as the beetles)
-        self.max_kmeans_label = int(image_properties_df.kmeans_label[image_properties_df['area'] == image_properties_df['area'].max()])
-        image_selected_df = image_properties_df[image_properties_df['kmeans_label']==self.max_kmeans_label]
-        self.image_properties_df = image_properties_df
-        # enlarge the boxes around blobs with buffer
-        coord_df = image_selected_df.loc[:,['bbox-0','bbox-1','bbox-2','bbox-3']].copy()
-        coord_df = coord_df.reset_index(drop = True)
-        image_selected_df = image_selected_df.reset_index(drop = True)
-        coord_df.loc[:,['bbox-0','bbox-1']] = coord_df.loc[:,['bbox-0','bbox-1']]-self.image_edge_buffer
-        coord_df.loc[:,['bbox-2','bbox-3']] = coord_df.loc[:,['bbox-2','bbox-3']]+self.image_edge_buffer
-        image_selected_df.loc[:,['bbox-0','bbox-1','bbox-2','bbox-3']] = coord_df.loc[:,['bbox-0','bbox-1','bbox-2','bbox-3']]
-        # limit boundaries to the initial image size without this the iamge size bugs out when the boundaries are negative and it removes the image
-        mask = image_selected_df[['bbox-0','bbox-1','bbox-2','bbox-3']]>=0
-        image_selected_df[['bbox-0','bbox-1','bbox-2','bbox-3']] = image_selected_df[['bbox-0','bbox-1','bbox-2','bbox-3']].where(mask, other=0)
-        self.image_selected_df = image_selected_df
-        # crop blobs from image based on box sizes and add to list
-        col_image_lst = []
-        inv_bw_image_lst = []
-        for i in range(len(image_selected_df)):
-            coord_i = image_selected_df.iloc[i]
-            # color images
-            crop_img = self.image[int(coord_i['bbox-0']):int(coord_i['bbox-2']), int(coord_i['bbox-1']):int(coord_i['bbox-3'])]
-            col_image_lst.append(crop_img)
-            # inverted black and white images
-            crop_bw_img = self.inv_bw_image[int(coord_i['bbox-0']):int(coord_i['bbox-2']), int(coord_i['bbox-1']):int(coord_i['bbox-3'])]
-            inv_bw_image_lst.append(crop_bw_img)
-        
-        #clear all images that are empty
-        # col_image_lst = [x for x in col_image_lst if x.shape[0] != 0] 
-        # inv_bw_image_lst = [x for x in inv_bw_image_lst if x.shape[0] != 0]
-        
-        self.col_image_lst = col_image_lst
-        self.inv_bw_image_lst = inv_bw_image_lst
-        self.image_segment_count = len(col_image_lst)
-        
-    def detect_outlier(self):
-        # convert list to numpy array
-        self.image_array = np.copy(np.array(self.col_image_lst, dtype='object'))
-        # initialize lists to store data in
-        r_ar_lst = []
-        g_ar_lst = []
-        b_ar_lst = []
-        all_ar_lst = []
-        for l in range(self.image_segment_count):
-            # flatten arrays
-            img_var = self.image_array[l]
-            r_ar = img_var[:,:,0].flatten() # red
-            g_ar = img_var[:,:,1].flatten() # green
-            b_ar = img_var[:,:,2].flatten() # blue
-            all_ar = img_var.flatten() # all
-            # collect data in lists
-            r_ar_lst.append(r_ar)
-            g_ar_lst.append(g_ar)
-            b_ar_lst.append(b_ar)
-            all_ar_lst.append(all_ar)
-        self.r_ar_lst = r_ar_lst
-        self.g_ar_lst = g_ar_lst
-        self.b_ar_lst = b_ar_lst
-        self.all_ar_lst = all_ar_lst
-        # get frequency of values at each rgb value(0-255)
-        values_array = all_ar_lst # use all, but can use any color
-        temp_dist_ar = np.zeros(shape=(255, self.image_segment_count))
-        for i in range(self.image_segment_count):
-            unique, counts = np.unique(values_array[i], return_counts=True)
-            temp_dict = dict(zip(unique, counts))
-            for j in temp_dict.keys():
-                temp_dist_ar[j-1][i] = temp_dict[j]
-        self.px_dens_dist = temp_dist_ar
-        # calculate the spearman correlation of distributions between images
-        # use spearman because it is a non-parametric measures
-        # use the sum of the correlation coefficients to identify the outlier image
-        corr_ar = np.array(spearmanr(temp_dist_ar, axis=0))
-        corr_coef_ar = corr_ar[0,:,:]
-        corr_pval_ar = corr_ar[1,:,:]
-        corr_sum_ar = corr_coef_ar.sum(axis=0)
-        self.corr_coef = corr_coef_ar
-        self.corr_pval = corr_pval_ar
-        self.corr_coef_sum = corr_sum_ar
-        self.outlier_idx = corr_sum_ar.argmin()
-        self.outlier_val = corr_sum_ar.min()
-        self.outlier_col_image = self.col_image_lst[self.outlier_idx]
-        self.outlier_inv_bw_image = self.inv_bw_image_lst[self.outlier_idx]
-        self.outlier_bw_image = np.invert(self.outlier_inv_bw_image)
-        # update metadata dataframe
-        self.image_selected_df['circle_class'] = 'non_circle'
-        self.image_selected_df.loc[self.outlier_idx, 'circle_class'] = 'circle'
-        
-    def estimate_size(self, outlier_idx, known_radius=1, canny_sigma=5):
-        for i in range(len(self.corr_coef_sum)):
-            # add appropriate data to dataframe when circle not detected at all
-            if i == (len(self.corr_coef_sum)-1):
-                self.outlier_idx = None
-                self.outlier_val = None
-                self.outlier_col_image = None
-                self.outlier_inv_bw_image = None
-                self.outlier_bw_image = None
-                # update metadata dataframe
-                self.image_selected_df['circle_class'] = 'non_circle'
-                self.image_selected_df['real_area'] = 0
-                clean_inv_bw_image_lst = []
-                for inv_bw_image in self.inv_bw_image_lst:
-                    # bw_image = np.invert(inv_bw_image)
-                    clean_inv_bw_image = clear_border(inv_bw_image)
-                    clean_inv_bw_image_lst.append(clean_inv_bw_image)
-                px_count_lst = []
-                for bw_img in clean_inv_bw_image_lst:
-                    unique_px_count = np.unique(bw_img, return_counts=True)
-                    px_dict = dict(zip(list(unique_px_count[0]), list(unique_px_count[1])))
-                    if len(px_dict) == 1:
-                        px_count = 0
-                    else:
-                        px_count = px_dict[True]
-                    px_count_lst.append(px_count)
-                self.image_selected_df['pixel_count'] = px_count_lst
-                print("Circle could not be found: "+str(self.image_dir))
-            else:
-                try:
-                    self.outlier_idx = np.argsort(self.corr_coef_sum)[i]
-                    self.outlier_val = np.sort(self.corr_coef_sum)[i]
-                    self.outlier_col_image = self.col_image_lst[self.outlier_idx]
-                    self.outlier_inv_bw_image = self.inv_bw_image_lst[self.outlier_idx]
-                    self.outlier_bw_image = np.invert(self.outlier_inv_bw_image)
-                    # update metadata dataframe
-                    self.image_selected_df['circle_class'] = 'non_circle'
-                    self.image_selected_df.loc[self.outlier_idx, 'circle_class'] = 'circle'
-                    outlier_inv_bw_image = np.invert(self.outlier_bw_image)
-                    # remove the border touching blobs of all b&w images
-                    clean_inv_bw_image_lst = []
-                    for inv_bw_image in self.inv_bw_image_lst:
-                        # bw_image = np.invert(inv_bw_image)
-                        clean_inv_bw_image = clear_border(inv_bw_image)
-                        clean_inv_bw_image_lst.append(clean_inv_bw_image)
-                    # default is the image detected with detect_outlier
-                    # change outlier_bw_image if this is not the ball bearing
-                    edges = canny(self.outlier_bw_image, sigma=canny_sigma)
-                    # Detect radius
-                    max_r = int((max(outlier_inv_bw_image.shape)/2) + (self.image_edge_buffer/2)) # max radius
-                    min_r = int((max_r-self.image_edge_buffer) - (self.image_edge_buffer/2)) # min radius
-                    hough_radii = np.arange(min_r, max_r, 10)
-                    hough_res = hough_circle(edges, hough_radii)
-                    # Select the most prominent circle
-                    accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=1)
-                    circy, circx = disk((cy[0], cx[0]), radii[0])
-                    # change the outlier image to fill in the circle
-                    outlier_inv_bw_image[circy, circx] = True # this index error occurs when the outlier object circle does not fit into the image
-
-                    self.outlier_inv_bw_image = clear_border(outlier_inv_bw_image)
-                    clean_inv_bw_image_lst[self.outlier_idx] = self.outlier_inv_bw_image
-                    self.clean_inv_bw_image_lst = clean_inv_bw_image_lst
-                    # get the area of the ball bearing based on the known radius
-                    circle_area = np.pi*(known_radius**2)
-                    px_count_lst = []
-                    for bw_img in clean_inv_bw_image_lst:
-                        px_count = np.unique(bw_img, return_counts=True)[1][1] # this index error occurs when the outlier object touches the edge of the image (forces recalculation of outlier)
-                        px_count_lst.append(px_count)
-                    self.image_selected_df['pixel_count'] = px_count_lst
-                    circle_px_count = px_count_lst[self.outlier_idx]
-                    area_ar = (np.array(px_count_lst)/circle_px_count)*circle_area
-                    self.image_selected_df['real_area'] = area_ar
-
-                    break
-
-                except IndexError:
-                    print('Updating circle classification for image: '+ str(self.image_dir))
-
-                else:
-                    print("No circle was found to estimate beetle size")
-                
-# add a section at line 219 that labels all area as 0 and all circle_class as non_circle when the least outlying object is considered.