def findBvPeaks(gp1_2d_array): #bandwidth = 'scott' kde = stats.kde.gaussian_kde( ( gp1_2d_array.T[0][:], gp1_2d_array.T[1][:] ))#, bw_method = bandwidth ) div = 128j # Regular grid to evaluate kde upon x_flat = np.r_[gp1_2d_array[:,0].min():gp1_2d_array[:,0].max():div] y_flat = np.r_[gp1_2d_array[:,1].min():gp1_2d_array[:,1].max():div] x,y = np.meshgrid(x_flat,y_flat) grid_coords = np.append(x.reshape(-1,1),y.reshape(-1,1),axis=1) z = kde(grid_coords.T) div_real = 128 z = z.reshape(div_real,div_real) #plotDistro(kde,(u_min,u_max),(v_min,v_max),title='') limg = np.arcsinh(z) limg = limg / limg.max() low = np.percentile(limg, 0.25) high = np.percentile(limg, 99.9) opt_img = skie.exposure.rescale_intensity(limg, in_range=(low,high)) lm = morph.is_local_maximum(limg) x1, y1 = np.where(lm.T == True) v = limg[(y1, x1)] lim = 0.6*high fp = 13 #smaller odd values are more sensitive to local maxima in image (use roughtly 5 thru 13) lm = morph.is_local_maximum(limg,footprint=np.ones((fp, fp))) x1, y1 = np.where(lm.T == True) v = limg[(y1, x1)] peaks = [[],[]] for idx in range(0,len(x1)): if limg[(y1[idx],x1[idx])] > lim: peaks[0].append(x1[idx]) peaks[1].append(y1[idx]) fig = plt.figure() img = plt.imshow(opt_img,origin='lower',interpolation='bicubic')#,cmap=cm.spectral) ax = fig.add_subplot(111) ax.scatter(peaks[0],peaks[1], s=100, facecolor='none', edgecolor = '#009999') #plt.savefig(OUTPUT_DATA_DIR + '_peaks.png') plt.colorbar() plt.show() return peaks
def findBivariatePeaks(kde): # Regular grid to evaluate kde upon x_flat = np.r_[start:end:div] y_flat = np.r_[start:end:div] x, y = np.meshgrid(x_flat, y_flat) grid_coords = np.append(x.reshape(-1, 1), y.reshape(-1, 1), axis=1) z = kde(grid_coords.T) z = z.reshape(div_real, div_real) #fig = plt.figure() #i = plt.imshow(z)#,aspect=x_flat.ptp()/y_flat.ptp(),origin='lower') #plt.show() limg = np.arcsinh(z) limg = limg / limg.max() low = np.percentile(limg, 0.25) high = np.percentile(limg, 99.9) opt_img = skie.exposure.rescale_intensity(limg, in_range=(low, high)) lm = morph.is_local_maximum(limg) x1, y1 = np.where(lm.T == True) v = limg[(y1, x1)] lim = 0.6 * high #x2, y2 = x1[v > lim], y1[x > lim] peaks = [[], []] for idx in range(0, len(x1)): if limg[(y1[idx], x1[idx])] > lim: peaks[0].append(x1[idx]) peaks[1].append(y1[idx]) #print peaks #print x_flat[peaks[0]] #print y_flat[peaks[1]] num_peaks = len(peaks[0]) peak_distances = [] max_peak_distance = 0 peak_vels = [] peak_probs = [] for idx in range(0, len(peaks[0][:])): peak_vels.append((x_flat[peaks[0][idx]], y_flat[peaks[1][idx]])) peak_probs.append( kde((x_flat[peaks[0][idx]], y_flat[peaks[1][idx]]))[0]) if len(peaks[0]) > 1: for idx in range(0, len(peaks[0])): for idx2 in range(0, len(peaks[1])): peak_distances.append(math.sqrt(math.pow(x_flat[peaks[0][idx]]-x_flat[peaks[0][idx2]],2) \ + math.pow(y_flat[peaks[1][idx]] - y_flat[peaks[1][idx2]],2))) max_peak_distance = max(peak_distances) print " %%max peak dist%% = " + str(max_peak_distance) return peak_vels, peak_probs, max_peak_distance
def contour_features(im): """features 19- 24; contours of the image: number of contours in the image, mean of distance to background, and local maxima:pixel ratio""" contours=[] x_size=int(im.size[1]/float(10)) i=im.resize((x_size,int((im.size[0]/float(im.size[1])*x_size)))) x=i.getdata() z=np.array(x) if z.size/(len(z))==1: if z.size%3 !=0: z= z[0:len(z)-len(z)%3] z= z.reshape(-1,3) #print z.resize(z.size/float(3),3) #print z #contour mapping contour_array=measure.find_contours(z,0.5) len_contours=contours.__len__() contours.append(len_contours) # 19-21: distance features: use ndimage.distance to compute "distance" to background of each pixel. Then find mean among x, y, and z values (r,g,b) distance=ndimage.distance_transform_edt(z) yvaluemean= sum(distance[:,0])/len(distance[:,0]) xvaluemean= sum(distance[:,1])/len(distance[:,1]) zvaluemean= sum(distance[:,2])/len(distance[:,2]) contours.append(yvaluemean) contours.append(xvaluemean) contours.append(zvaluemean) #22-24: local_max features: find number of local maxima among x,y,z values (rgb) compared to the number of pixels local_max=is_local_maximum(distance,z,np.ones((3,3))) xmaxsum, ymaxsum, zmaxsum = [0,0,0] for a in (local_max[:,0]): if a ==False: xmaxsum+=1 contours.append(xmaxsum/float(len(local_max[:,0]))) for a in (local_max[:,1]): if a ==False: ymaxsum+=1 contours.append(ymaxsum/float(len(local_max[:,0]))) for a in (local_max[:,2]): if a ==False: zmaxsum+=1 contours.append(zmaxsum/float(len(local_max[:,0]))) ###25: object count filt_img=ndimage.gaussian_filter(z,10) T=70 labeled,nr_objects=ndimage.label(filt_img>T) contours.append(nr_objects) return contours
from skimage.morphology import watershed, is_local_maximum import matplotlib.pyplot as plt from scipy import ndimage # Generate an initial image with two overlapping circles x, y = np.indices((80, 80)) x1, y1, x2, y2 = 28, 28, 44, 52 r1, r2 = 16, 20 mask_circle1 = (x - x1) ** 2 + (y - y1) ** 2 < r1 ** 2 mask_circle2 = (x - x2) ** 2 + (y - y2) ** 2 < r2 ** 2 image = np.logical_or(mask_circle1, mask_circle2) # Now we want to separate the two objects in image # Generate the markers as local maxima of the distance # to the background distance = ndimage.distance_transform_edt(image) local_maxi = is_local_maximum(distance, image, np.ones((3, 3))) markers = ndimage.label(local_maxi)[0] labels = watershed(-distance, markers, mask=image) plt.figure(figsize=(9, 3.5)) plt.subplot(131) plt.imshow(image, cmap='gray', interpolation='nearest') plt.axis('off') plt.subplot(132) plt.imshow(-distance, interpolation='nearest') plt.axis('off') plt.subplot(133) plt.imshow(labels, cmap='spectral', interpolation='nearest') plt.axis('off') plt.subplots_adjust(hspace=0.01, wspace=0.01, top=1, bottom=0, left=0,
bkg = func(grid_x, grid_y) bkg = bkg / np.max(bkg) # Creating points clean = np.zeros((200, 400)) clean[(x, y)] += 5 clean = ndimage.gaussian_filter(clean, 3) clean = clean / np.max(clean) # Combining both the non-uniform background # and points fimg = bkg + clean fimg = fimg / np.max(fimg) # Calculating local maxima lm1 = morph.is_local_maximum(fimg) x1, y1 = np.where(lm1.T == True) # Creating figure to show local maximum detection # rate success fig = plt.figure(figsize=(8, 4)) ax = fig.add_subplot(111) ax.imshow(fimg) ax.scatter(x1, y1, s=100, facecolor='none', edgecolor='#009999') ax.set_xlim(0, 400) ax.set_ylim(0, 200) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) fig.savefig('scikits_412_ex1.png', bbox_inches='tight')
import matplotlib.pyplot as plt from skimage.morphology import watershed, is_local_maximum # Generate an initial image with two overlapping circles x, y = np.indices((80, 80)) x1, y1, x2, y2 = 28, 28, 44, 52 r1, r2 = 16, 20 mask_circle1 = (x - x1)**2 + (y - y1)**2 < r1**2 mask_circle2 = (x - x2)**2 + (y - y2)**2 < r2**2 image = np.logical_or(mask_circle1, mask_circle2) # Now we want to separate the two objects in image # Generate the markers as local maxima of the distance to the background from scipy import ndimage distance = ndimage.distance_transform_edt(image) local_maxi = is_local_maximum(distance, image, np.ones((3, 3))) markers = ndimage.label(local_maxi)[0] labels = watershed(-distance, markers, mask=image) fig, axes = plt.subplots(ncols=3, figsize=(8, 2.7)) ax0, ax1, ax2 = axes ax0.imshow(image, cmap=plt.cm.gray, interpolation='nearest') ax1.imshow(-distance, cmap=plt.cm.jet, interpolation='nearest') ax2.imshow(labels, cmap=plt.cm.spectral, interpolation='nearest') for ax in axes: ax.axis('off') plt.subplots_adjust(hspace=0.01, wspace=0.01, top=1, bottom=0, left=0, right=1) plt.show()
bkg = func(grid_x, grid_y) bkg = bkg / np.max(bkg) # Creating points clean = np.zeros((200, 400)) clean[(x, y)] += 5 clean = ndimage.gaussian_filter(clean, 3) clean = clean / np.max(clean) # Combining both the non-uniform background # and points fimg = bkg + clean fimg = fimg / np.max(fimg) # Calculating local maxima lm1 = morph.is_local_maximum(fimg) x1, y1 = np.where(lm1.T == True) # Creating figure to show local maximum detection # rate success fig = plt.figure(figsize=(8, 4)) ax = fig.add_subplot(111) ax.imshow(fimg) ax.scatter(x1, y1, s=100, facecolor="none", edgecolor="#009999") ax.set_xlim(0, 400) ax.set_ylim(0, 200) ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) fig.savefig("scikits_412_ex1.pdf", bbox_inches="tight")
def test_target(tar): ''' if the convexity of the target is <threshold try to do a watershed segmentation make black image with white polygon do watershed segmentation find polygon center ''' def test(ti): ctest = ti.convexity > threshold centtest = self._near_center(*ti.centroid_value) atest = ma > ti.area > mi return ctest, centtest, atest ctest, centtest, atest = test(tar) if not ctest and (atest and centtest): # src = self.target_image.get_frame(0) # self._draw_result(src, tar) # w, h = self.croppixels # self.target_image.save('/Users/ross/Sandbox/machine_vision/polygon.jpg', width=w, height=h) src = self.target_image.get_frame(0) draw_polygons(src, [tar.poly_points], color=(0, 255, 255)) # make image with polygon image = zeros(self.croppixels) points = asarray(tar.poly_points) points = asarray([(pi.x, pi.y) for pi in points]) rr, cc = polygon(points[:, 0], points[:, 1]) image[cc, rr] = 255 # do watershedding distance = ndimage.distance_transform_edt(image) local_maxi = is_local_maximum(distance, image) markers, ns = ndimage.label(local_maxi) wsrc = watershed(-distance, markers, mask=image ) # find the label with the max area ie max of histogram def get_limits(values, bins): ind = argmax(values) if ind == 0: bil = bins[ind] biu = bins[ind + 1] elif ind == len(bins) - 1: bil = bins[ind - 1] biu = bins[ind] else: bil = bins[ind - 1] biu = bins[ind + 1] return bil, biu, ind # bins = 3 * number of labels. this allows you to precisely pick the value of the max area values, bins = histogram(wsrc, bins=ns * 3) bil, biu, ind = get_limits(values, bins) if not bil: values = delete(values, ind) bins = delete(bins, (ind, ind + 1)) bil, biu, ind = get_limits(values, bins) # print values # print bins # print bil, biu nimage = ones_like(wsrc, dtype='uint8') nimage[wsrc < bil] = 0 nimage[wsrc > biu] = 0 img = asMat(nimage) # locate new polygon from the segmented image tars = self._locate_targets(img) if globalv.show_autocenter_debug_image: do_later(lambda: self.debug_show(image, distance, wsrc, nimage)) if tars: tar = tars[0] ctest, centtest, atest = test(tar) # ctest = tar.convexity > threshold # centtest = self. else: return None, False return tar, ctest and atest and centtest
peak_distances = [] for idx in range(0,len(contour_centroids)): for idx2 in range(0,len(contour_centroids)): peak_distances.append(math.sqrt(math.pow(contour_centroids[idx][0]-contour_centroids[idx2][0],2) \ + math.pow(contour_centroids[idx][1] - contour_centroids[idx2][1],2))) ''' limg = np.arcsinh(z) limg = limg / limg.max() low = np.percentile(limg, 0.25) high = np.percentile(limg, 99.9) opt_img = skie.exposure.rescale_intensity(limg, in_range=(low, high)) lm = morph.is_local_maximum(limg) x1, y1 = np.where(lm.T == True) v = limg[(y1, x1)] lim = 0.6 * high #x2, y2 = x1[v > lim], y1[x > lim] peaks = [[], []] for idx in range(0, len(x1)): if limg[(y1[idx], x1[idx])] > lim: peaks[0].append(x1[idx]) peaks[1].append(y1[idx]) print peaks peak_distances = [] for idx in range(0, len(peaks)):
import skimage.morphology as morph import skimage.exposure as skie import matplotlib.pyplot as plt # Loading astronomy image from an infrared space telescope img = pyfits.getdata('stellar_cluster.fits')[500:1500, 500:1500] # Prep file scikit-image environment and plotting limg = np.arcsinh(img) limg = limg / limg.max() low = np.percentile(limg, 0.25) high = np.percentile(limg, 99.5) opt_img = skie.exposure.rescale_intensity(limg, in_range=(low, high)) # Calculating local maxima and filtering out noise lm = morph.is_local_maximum(limg) x1, y1 = np.where(lm.T == True) v = limg[(y1, x1)] lim = 0.5 x2, y2 = x1[v > lim], y1[v > lim] # Creating figure to show local maximum detection # rate success fig = plt.figure(figsize=(8, 4)) fig.subplots_adjust(hspace=0.05, wspace=0.05) ax1 = fig.add_subplot(121) ax1.imshow(opt_img) ax1.set_xlim(0, img.shape[1]) ax1.set_ylim(0, img.shape[0]) ax1.xaxis.set_visible(False)
if seg == 'edge detection': # perform edge detection. Different edge filters are available in Python, here the Sobel filter is used edges = sobel(image) # threshold edges to select only strong contours (NB: intensity values (0-255) are normalized between 0 and 1) image_segmented = edges > 0.1 # fill potential holes in segmented objects image_segmented_filled = nd.binary_fill_holes(image_segmented) #watershed segmentation to split touching objects, if activated in the user's section if ws == '_ws_': # distance map is created where the distance of each foreground pixel to the closest background pixel is calculated and used for watershed splitting distance = nd.distance_transform_edt(image_segmented_filled) # apply Gaussian filter to the distance map to merge several local maxima into one distance=nd.gaussian_filter(distance,4) local_maxi = is_local_maximum(distance, labels=image_segmented_filled, footprint=np.ones((3, 3))) markers = nd.label(local_maxi)[0] # return labelled image (array of unique integers per object) labelled_image = watershed(-distance, markers, mask=image_segmented_filled) # 2b. WATERSHED SPLIT #-------------------- # return labelled image (array of unique integers per object) if ws != '_ws_': labelled_image, nb_labels = nd.label(image_segmented_filled) # 3. MEASURE OBJECT PROPERTIES AND CONDUCT SIZE-BASED EXCLUSION #-------------------------------------------------------------- # measure object size on labelled image