Spaces:
Sleeping
Sleeping
| # 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. |