def apply_filters(images, sigmas): """ Apply multiple filters to 'images' """ filtered_images = [] for img in images: filtered = [] for sigma in sigmas: for conv_filter in [ gaussian_filter, gaussian_laplace, gaussian_gradient_magnitude ]: filtered.append(conv_filter(img, sigma)) # *_eigenvals has changed from version 0.13 to 0.14. try: # v. 0.14 eigs_struc = structure_tensor_eigvals( *structure_tensor(img, sigma=sigma)) eigs_hess = hessian_matrix_eigvals( hessian_matrix(img, sigma=sigma, order="xy")) except TypeError as e: # v. 0.13 eigs_struc = structure_tensor_eigvals( *structure_tensor(img, sigma=sigma)) eigs_hess = hessian_matrix_eigvals( *hessian_matrix(img, sigma=sigma, order="xy")) for eig_h, eig_s in zip(eigs_struc, eigs_hess): filtered.append(eig_h) filtered.append(eig_s) filtered.append(equalize_hist(img)) #selem = disk(30) #filtered.append(equalize(img, selem=selem)) filtered_images.append(filtered) return np.array(filtered_images)
def get_feature_one(img, msk=None, para=para): chans, grade, w, items = para['chans'], para['grade'], para['w'], para[ 'items'] feats, titles = [], [] img = img.reshape(img.shape[:2] + (-1, )) if msk is None: msk = np.ones(img.shape[:2], dtype=np.bool) if chans is None: chans = range(img.shape[2]) for c in [chans] if isinstance(chans, int) else chans: if 'ori' in items: feats.append(img[:, :, c][msk].astype(np.float32)) titles.append('c%d_ori' % c) for o in range(grade): blurimg = ndimg.gaussian_filter(img[:, :, c], 2**o, output=np.float32) feat_sobel = sobel(blurimg)[msk] if 'sob' in items else None if 'eig' in items: Axx, Axy, Ayy = structure_tensor(blurimg, w) l1, l2 = structure_tensor_eigvals(Axx, Axy, Ayy) feat_l1, feat_l2 = l1[msk], l2[msk] else: feat_l1 = feat_l2 = None feat_gauss = blurimg[msk] if 'blr' in items else None featcr = [feat_gauss, feat_sobel, feat_l1, feat_l2] title = [ 'c%d_s%d_%s' % (c, o, i) for i in ['gauss', 'sobel', 'l1', 'l2'] ] titles.extend( [title[i] for i in range(4) if not featcr[i] is None]) feats.extend( [featcr[i] for i in range(4) if not featcr[i] is None]) return np.array(feats).T, titles
def local_shape_features_minmax(im, scaleStart): """ Creates features based on those in the Luca Fiaschi paper but on 5 scales independent of object size, but using a gaussian pyramid to calculate at multiple scales more efficiently and then linear upsampling to original image scale also includes gaussian smoothed image """ # Smoothing and scale parameters chosen to approximate those in 'fine' # features imSizeC = im.shape[0] imSizeR = im.shape[1] f = np.zeros((imSizeC, imSizeR, 31)) f[:, :, 0] = im # create pyramid structure pyr = skimage.transform.pyramid_gaussian(im, sigma=1.5, max_layer=5, downscale=2, multichannel=False) a = im for layer in range(0, 5): # calculate scale scale = [ float(im.shape[0]) / float(a.shape[0]), float(im.shape[1]) / float(a.shape[1]) ] # create features lap = scipy.ndimage.filters.laplace(a) [m, n] = np.gradient(a) ggm = np.hypot(m, n) x, y, z = skfeat.structure_tensor(a, 1) st = skfeat.structure_tensor_eigvals(x, y, z) maxim = scipy.ndimage.maximum_filter(a, 3) minim = scipy.ndimage.minimum_filter(a, 3) # upsample features to original image lap = scipy.ndimage.interpolation.zoom(lap, scale, order=1) ggm = scipy.ndimage.interpolation.zoom(ggm, scale, order=1) st0 = scipy.ndimage.interpolation.zoom(st[0], scale, order=1) st1 = scipy.ndimage.interpolation.zoom(st[1], scale, order=1) maxim = scipy.ndimage.interpolation.zoom(maxim, scale, order=1) minim = scipy.ndimage.interpolation.zoom(minim, scale, order=1) f[:, :, layer * 6 + 1] = lap f[:, :, layer * 6 + 2] = ggm f[:, :, layer * 6 + 3] = st0 f[:, :, layer * 6 + 4] = st1 f[:, :, layer * 6 + 5] = minim f[:, :, layer * 6 + 6] = maxim # get next layer a = next(pyr) return f
def test_structure_tensor_eigvals(): square = np.zeros((5, 5)) square[2, 2] = 1 A_elems = structure_tensor(square, sigma=0.1, order='rc') with expected_warnings(['structure_tensor_eigvals is deprecated']): eigvals = structure_tensor_eigvals(*A_elems) eigenvalues = structure_tensor_eigenvalues(A_elems) assert_array_equal(eigvals, eigenvalues)
def run(self, ips, snap, img, para=None): axx, axy, ayy = structure_tensor(snap, sigma=para['sigma']) l1, l2 = structure_tensor_eigvals(axx, axy, ayy) if para['axis'] == 'major': rst = l1 elif para['axis'] == 'minor': rst = l2 else: rst = (l1**2 + l2**2)**0.5 if para['log']: rst += 1 np.log(rst, out=rst) img[:] = scale(rst, ips.range[0], ips.range[1])
def calculate_skfeat_eigenvalues(im, s): #designed to be similar to vigra use of vigra.filters.structureTensorEigenvalues #slight differences in results gim = scipy.ndimage.filters.gaussian_filter(im, 0.5 * s, mode='reflect', truncate=4) x, y, z = skfeat.structure_tensor(gim, 1 * s, mode='reflect') st_skfeat = skfeat.structure_tensor_eigvals(x, y, z) return ((st_skfeat[0] / (50 + s)), (st_skfeat[1] / (50 + s)))
def test_structure_tensor_eigvals(): square = np.zeros((5, 5)) square[2, 2] = 1 Axx, Axy, Ayy = structure_tensor(square, sigma=0.1) l1, l2 = structure_tensor_eigvals(Axx, Axy, Ayy) assert_array_equal( l1, np.array([[0, 0, 0, 0, 0], [0, 2, 4, 2, 0], [0, 4, 0, 4, 0], [0, 2, 4, 2, 0], [0, 0, 0, 0, 0]]) ) assert_array_equal( l2, np.array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) )
def test_structure_tensor_eigvals(): square = np.zeros((5, 5)) square[2, 2] = 1 Axx, Axy, Ayy = structure_tensor(square, sigma=0.1) l1, l2 = structure_tensor_eigvals(Axx, Axy, Ayy) assert_array_equal( l1, np.array([[0, 0, 0, 0, 0], [0, 2, 4, 2, 0], [0, 4, 0, 4, 0], [0, 2, 4, 2, 0], [0, 0, 0, 0, 0]])) assert_array_equal( l2, np.array([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]))
def stru(im): """Attempts to find edges in the image through use of structure tensor. Computes a mask of values that are higher mostly on edges by using the square difference of the structure tensor eigen values. Args: im: input greyscale image Returns: mask of values higher on edges than interiors (see above) """ A = structure_tensor(im, sigma = 0.8, mode="reflect") e1, e2 = structure_tensor_eigvals(*A) d = e1 + e2 st = np.where(d > np.finfo(np.float16).eps, (e1 - e2) ** 2, 0) return st[..., np.newaxis]
def read_image(self, image_name, size=None): options = self.get_options() if size: im = np.array(Image.open(image_name).convert("L").resize(size)) else: im = np.array(Image.open(image_name).convert("L")) options["image"] = im Axx, Axy, Ayy = structure_tensor(im) feature = structure_tensor_eigvals(Axx, Axy, Ayy)[0] # plt.imshow(feature) # plt.show() return feature.reshape((1, feature.shape[0] * feature.shape[1]))[0]
def _get_structure_tensor_features(im, features_window_size, sigma_st): features_arr = np.empty(0) assert im.shape[0] == im.shape[1], "image must have a square shape" center = im_center(im) Axx, Axy, Ayy = feature.structure_tensor(im, sigma=sigma_st) l1, l2 = feature.structure_tensor_eigvals(Axx, Axy, Ayy) l1 = utils.extract_pad_image(input_img=l1, pt=center, window_size=features_window_size) l2 = utils.extract_pad_image(input_img=l2, pt=center, window_size=features_window_size) l1 = arr_to_vec(l1) l2 = arr_to_vec(l2) features_arr = np.append(features_arr, l1) features_arr = np.append(features_arr, l2) return features_arr
def local_shape_features_fine_imhist(im, scaleStart): """As per pyramid features but with histogram equalisation""" imSizeC = im.shape[0] imSizeR = im.shape[1] f = np.zeros((imSizeC, imSizeR, 26)) im = exposure.equalize_hist(im) #im=exposure.equalize_adapthist(im, kernel_size=5) f[:, :, 0] = im # set up pyramid pyr = skimage.transform.pyramid_gaussian(im, sigma=1.5, max_layer=5, downscale=2, multichannel=False) a = im for layer in range(0, 5): scale = [ float(im.shape[0]) / float(a.shape[0]), float(im.shape[1]) / float(a.shape[1]) ] lap = scipy.ndimage.filters.laplace(a) [m, n] = np.gradient(a) ggm = np.hypot(m, n) x, y, z = skfeat.structure_tensor(a, 1) st = skfeat.structure_tensor_eigvals(x, y, z) lap = scipy.ndimage.interpolation.zoom(lap, scale, order=1) ggm = scipy.ndimage.interpolation.zoom(ggm, scale, order=1) st0 = scipy.ndimage.interpolation.zoom(st[0], scale, order=1) st1 = scipy.ndimage.interpolation.zoom(st[1], scale, order=1) up = scipy.ndimage.interpolation.zoom(a, scale, order=1) f[:, :, layer * 5 + 1] = lap f[:, :, layer * 5 + 2] = ggm f[:, :, layer * 5 + 3] = st0 f[:, :, layer * 5 + 4] = st1 f[:, :, layer * 5 + 5] = up a = next(pyr) return f
def create_features(p, x, y, r): """Create feature for patch Tested features: + Mean intensity of RGB CIE[:,:,0] + Mean intensity of RGB CIE[:,:,1] + Mean intensity of RGB CIE[:,:,2] + Mean intensity of HSV[:,:,0] + Canny edge image + Eigenvalues from structure tensor """ features = [] # Get patch/patches structure_img = p.get_version("structure")[:, :, 2] structure_patch = structure_img[int(y - r):int(y + r), int(x - r):int(x + r)] rgb_img = p.get_version("contrast_rgb_cie") rgb_patch = rgb_img[int(y - r):int(y + r), int(x - r):int(x + r)] # Color quantization with k_means # patch = quantize_colors(patch) # ==== FEATURES ======= # Median values of the individual color channels features.append(np.median(rgb_patch[:, :, 0])) features.append(np.median(rgb_patch[:, :, 1])) features.append(np.median(rgb_patch[:, :, 2])) # Edges edges = canny(structure_patch) features += edges.astype(float).ravel().tolist() # Structure Tensor Axx, Axy, Ayy = structure_tensor(structure_patch) l1, l2 = structure_tensor_eigvals(Axx, Axy, Ayy) features += l1.ravel().tolist() features += l2.ravel().tolist() return features
def create_features(p, x, y, r): """Create feature for patch Tested features: + Mean intensity of RGB CIE[:,:,0] + Mean intensity of RGB CIE[:,:,1] + Mean intensity of RGB CIE[:,:,2] + Mean intensity of HSV[:,:,0] + Canny edge image + Eigenvalues from structure tensor """ features = [] # Get patch/patches structure_img = p.get_version("structure")[:,:,2] structure_patch = structure_img[int(y-r):int(y+r), int(x-r):int(x+r)] rgb_img = p.get_version("contrast_rgb_cie") rgb_patch = rgb_img[int(y-r):int(y+r), int(x-r):int(x+r)] # Color quantization with k_means # patch = quantize_colors(patch) # ==== FEATURES ======= # Median values of the individual color channels features.append(np.median(rgb_patch[:,:,0])) features.append(np.median(rgb_patch[:,:,1])) features.append(np.median(rgb_patch[:,:,2])) # Edges edges = canny(structure_patch) features += edges.astype(float).ravel().tolist() # Structure Tensor Axx, Axy, Ayy = structure_tensor(structure_patch) l1, l2 = structure_tensor_eigvals(Axx, Axy, Ayy) features += l1.ravel().tolist() features += l2.ravel().tolist() return features
def normalize_image(img): """Normalize images. Normalize images by gaussian smoothing for noise, push background values to 0, and nuclei values toward 1 with sigmoid. The set parameters seemed not to damage boudnary information between nuclei too much. Args: img: greyscale image data Returns: normalized image """ img_2 = gaussian(img, sigma = 1) cut = np.mean(img_2) sig = adjust_sigmoid(img_2, cutoff = cut, gain = 5, inv = (cut > 0.5), ) sig = rescale_intensity(sig) sig_2 = gaussian(sig, sigma = 1) A = structure_tensor(sig_2, sigma = 0.8, mode = "reflect") e1, e2 = structure_tensor_eigvals(*A) d = e1 + e2 str_corr = np.where(d > np.finfo(np.float16).eps, (e1 - e2) ** 2, 0, ) bge = str_corr > np.mean(str_corr) * .01 bdy_grad_eigen = opening(remove_small_objects(bge, min_size = 64, connectivity = 2, ), ) gaus = gaussian(sig, sigma =1 ) out = np.where(bdy_grad_eigen, sig, gaus) out = rescale_intensity(out) return out.astype(np.float32)
def computeStructureFeatures(Xdata, isTraining, path): path = path + '/structFeatures' print("\nComputing: All Structure Features") print("is Training? %r" %isTraining) start = time.time() # Separate color channel RChannel = Xdata[:,:,0] GChannel = Xdata[:,:,1] BChannel = Xdata[:,:,2] # Calculate Laplacian of Gaussian (sigma = 1.6) print("Computing: Laplacian of Gaussian") gaussianLF_R = gaussian_laplace(RChannel, 1.6) gaussianLF_G = gaussian_laplace(GChannel, 1.6) gaussianLF_B = gaussian_laplace(BChannel, 1.6) gaussianLF = np.dstack((gaussianLF_R, gaussianLF_G, gaussianLF_B)) gaussianLF = np.resize(gaussianLF, (gaussianLF.shape[0]*gaussianLF.shape[1], gaussianLF.shape[2])) end = time.time() if (isTraining): print("Computed: gaussianLapFeatures_Tr in %f seconds" %(end-start)) # with open('gaussianLapFeatures_Tr.pkl','wb') as outfile: # pickle.dump(gaussianLF, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianLapFeatures_Tr.csv", # gaussianLF, delimiter=",") else: print("Computed: gaussianLapFeatures_Ts in %f seconds" %(end-start)) # with open('gaussianLapFeatures_Ts.pkl','wb') as outfile: # pickle.dump(gaussianLF, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianLapFeatures_Ts.csv", # gaussianLF, delimiter=",") # Calculate eigenvalues of structure tensor (sigma =1.6, 3.5) print("Computing: eigenvalues of structure tensor") start = time.time() Axx_R1, Axy_R1, Ayy_R1 = structure_tensor(RChannel, sigma = 1.6) larger_R1, smaller_R1 = structure_tensor_eigvals(Axx_R1, Axy_R1, Ayy_R1) Axx_R2, Axy_R2, Ayy_R2 = structure_tensor(RChannel, sigma = 3.5) larger_R2, smaller_R2 = structure_tensor_eigvals(Axx_R2, Axy_R2, Ayy_R2) Axx_G1, Axy_G1, Ayy_G1 = structure_tensor(GChannel, sigma = 1.6) larger_G1, smaller_G1 = structure_tensor_eigvals(Axx_G1, Axy_G1, Ayy_G1) Axx_G2, Axy_G2, Ayy_G2 = structure_tensor(GChannel, sigma = 3.5) larger_G2, smaller_G2 = structure_tensor_eigvals(Axx_G2, Axy_G2, Ayy_G2) Axx_B1, Axy_B1, Ayy_B1 = structure_tensor(BChannel, sigma = 1.6) larger_B1, smaller_B1 = structure_tensor_eigvals(Axx_B1, Axy_B1, Ayy_B1) Axx_B2, Axy_B2, Ayy_B2 = structure_tensor(BChannel, sigma = 3.5) larger_B2, smaller_B2 = structure_tensor_eigvals(Axx_B2, Axy_B2, Ayy_B2) eigenST = np.dstack((larger_R1, smaller_R1, larger_R2, smaller_R2, larger_G1, smaller_G1, larger_G2, smaller_G2, larger_B1, smaller_B1, larger_B2, smaller_B2)) eigenST = np.resize(eigenST, (eigenST.shape[0]*eigenST.shape[1], eigenST.shape[2])) end = time.time() if (isTraining): print("Computed: eigenStructFeatures_Tr in %f seconds" %(end-start)) # with open('eigenStructFeatures_Tr.pkl','wb') as outfile: # pickle.dump(eigenST, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenStructFeatures_Tr.csv", # eigenST, delimiter=",") else: print ("Computed: eigenStructFeatures_Ts in %f seconds" %(end-start)) # with open('eigenStructFeatures_Ts.pkl','wb') as outfile: # pickle.dump(eigenST, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenStructFeatures_Ts.csv", # eigenST, delimiter=",") # Calculate eigenvalues of Hessian matrix print("Computing: eigenvalues of Hessian matrix") start = time.time() Hrr_R1, Hrc_R1, Hcc_R1 = hessian_matrix(RChannel, sigma = 1.6, order='rc') larger_R1, smaller_R1 = hessian_matrix_eigvals(Hrr_R1, Hrc_R1, Hcc_R1) Hrr_R2, Hrc_R2, Hcc_R2 = hessian_matrix(RChannel, sigma = 3.5, order='rc') larger_R2, smaller_R2 = hessian_matrix_eigvals(Hrr_R2, Hrc_R2, Hcc_R2) Hrr_G1, Hrc_G1, Hcc_G1 = hessian_matrix(GChannel, sigma = 1.6, order='rc') larger_G1, smaller_G1 = hessian_matrix_eigvals(Hrr_G1, Hrc_G1, Hcc_G1) Hrr_G2, Hrc_G2, Hcc_G2 = hessian_matrix(GChannel, sigma = 3.5, order='rc') larger_G2, smaller_G2 = hessian_matrix_eigvals(Hrr_G2, Hrc_G2, Hcc_G2) Hrr_B1, Hrc_B1, Hcc_B1 = hessian_matrix(BChannel, sigma = 1.6, order='rc') larger_B1, smaller_B1 = hessian_matrix_eigvals(Hrr_B1, Hrc_B1, Hcc_B1) Hrr_B2, Hrc_B2, Hcc_B2 = hessian_matrix(BChannel, sigma = 3.5, order='rc') larger_B2, smaller_B2 = hessian_matrix_eigvals(Hrr_B2, Hrc_B2, Hcc_B2) eigenHess = np.dstack((larger_R1, smaller_R1, larger_R2, smaller_R2, larger_G1, smaller_G1, larger_G2, smaller_G2, larger_B1, smaller_B1, larger_B2, smaller_B2)) eigenHess = np.resize(eigenHess, (eigenHess.shape[0]*eigenHess.shape[1], eigenHess.shape[2])) end = time.time() if (isTraining): print("Computed: eigenHessFeatures_Tr in %f seconds" % (end-start)) # with open('eigenHessFeatures_Tr.pkl','wb') as outfile: # pickle.dump(eigenHess, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenHessFeatures_Tr.csv", # eigenHess, delimiter=",") else: print("Computed: eigenHessFeatures_Ts in %f seconds" % (end-start)) # with open('eigenHessFeatures_Ts.pkl','wb') as outfile: # pickle.dump(eigenHess, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/eigenHessFeatures_Ts.csv", # eigenHess, delimiter=",") # Calculate Gaussian gradient magnitude (sigma = 1.6) print("Computing: Gaussian gradient magnitude") start = time.time() gaussian_grad_R = gaussian_gradient_magnitude(RChannel, sigma = 1.6) gaussian_grad_G = gaussian_gradient_magnitude(GChannel, sigma = 1.6) gaussian_grad_B = gaussian_gradient_magnitude(BChannel, sigma = 1.6) gaussian_grad = np.dstack((gaussian_grad_R, gaussian_grad_G, gaussian_grad_B)) gaussian_grad = np.resize(gaussian_grad, (gaussian_grad.shape[0]*gaussian_grad.shape[1], gaussian_grad.shape[2])) end = time.time() if (isTraining): print("Computed: gaussianGradFeatures_Tr in %f seconds" % (end-start)) # with open('gaussianGradFeatures_Tr.pkl','wb') as outfile: # pickle.dump(gaussian_grad, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianGradFeatures_Tr.csv", # gaussian_grad, delimiter=",") else: print("Computed: gaussianGradFeatures_Ts in %f seconds" % (end-start)) # with open('gaussianGradFeatures_Ts.pkl','wb') as outfile: # pickle.dump(gaussian_grad, outfile, pickle.HIGHEST_PROTOCOL) # np.savetxt("/Users/wuwenjun/GitHub/CSE-577-Melanoma-Nuclei-Segmentation/gaussianGradFeatures_Ts.csv", # gaussian_grad, delimiter=",") All = np.concatenate((gaussianLF, eigenST, eigenHess, gaussian_grad),axis = 1) if (isTraining): path = path + '_Tr' np.savez_compressed(path, data = All) print("\nFINISHED: Structure Features for Training data\n") else: path = path + '_Ts' np.savez_compressed(path, data = All) print("\nFINISHED: Structure Features for Testing data\n")
#with timeit("canny"): im1 = feature.canny(im, sigma=2.5, low_threshold=0.7, high_threshold=0.99, use_quantiles=True) #edge detection #im1 = feature.canny(im, sigma=2.5, low_threshold=8, high_threshold=10, use_quantiles=False) #edge detection im2 = morphology.binary_fill_holes(im1, structure=struct).astype( int) #fill holes #im2 = morphology.binary_fill_holes(im1).astype(int) #fill holes im3 = morphology.binary_erosion(im2, structure=struct).astype( int) #erode to remove lines and small schmutz Axx, Axy, Ayy = feature.structure_tensor( im, sigma=0.5, mode='nearest') #structure im4 = feature.structure_tensor_eigvals(Axx, Axy, Ayy)[0] #structure im4 = im4 * morphology.binary_erosion( im3, structure=struct, iterations=4).astype(int) #structure label_image = label(im3) #label all ellipses (and other objects) if display == 2: #debug mode ax2.clear() ax2.set_axis_off() ax2.imshow(im4, cmap='gray') ax3.clear() ax3.set_axis_off() ax3.imshow(im2, cmap='gray') ax4.clear() ax4.set_axis_off() # ax4.imshow(im4,cmap='jet', vmin = 0, vmax = 3000 )
def image_preprocess(filename, nfeatures, original_image_array, sigmas=SIGMAS): global preprocess_counter x = 0 # For performance reasons, pre-allocate an empty 2D array of the right shape # and dimensions to contain all of the given image's pixels and features images = numpy.empty((nfeatures, original_image_array.size), dtype=numpy.uint8) # normalize our (32-bit grayscale) image to an 8-bit unsigned representation # to conserve memory and increase performance img = cv2.normalize(original_image_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) # the first feature is just the original normalized pixel value images[x] = img.flatten(order='F') x += 1 # insert original image # a set of features per pixel based on the image's filename which # encodes metadata related to the age class of the cell for age in AGE_CLASSES: img = label_age(original_image_array, age, filename) images[x] = img.flatten(order='F') x += 1 # call a series of parameterized image filters to extract features for s in sigmas: # Gaussian Smoothing img = gaussian_filter(original_image_array, sigma=s) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Sobel Edge Detection img = scipy.ndimage.sobel(original_image_array, mode='constant', cval=s) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Laplacian of Gaussian Edge Detection img = scipy.ndimage.gaussian_laplace(original_image_array, sigma=s) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Gaussian Gradient Magnitude Edge Detection img = scipy.ndimage.gaussian_gradient_magnitude(original_image_array, sigma=s) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Difference of Gaussians k = 1.7 # determined by trial and error tmp1_array = scipy.ndimage.gaussian_filter(original_image_array, sigma=s * k) tmp2_array = scipy.ndimage.gaussian_filter(original_image_array, sigma=s) img = (tmp1_array - tmp2_array) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Structure Tensor Eigenvalues Axx, Axy, Ayy = feature.structure_tensor( Image.fromarray(original_image_array), sigma=s) large_array, small_array = feature.structure_tensor_eigvals( Axx, Axy, Ayy) img = cv2.normalize(large_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(small_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Hessian Matrix Hrr, Hrc, Hcc = feature.hessian_matrix( Image.fromarray(original_image_array), sigma=s, order='rc') img = cv2.normalize(Hrr, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(Hrc, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(Hcc, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Generate proximity map (to center of image) newimg = center_proximity(original_image_array) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Simple Intensity Threshholding img = cv2.GaussianBlur(original_image_array, (5, 5), cv2.BORDER_WRAP) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) ret, img = cv2.threshold(img, 205, 255, cv2.THRESH_BINARY) images[x] = img.flatten(order='F') x += 1 # Flip the orientation of the flattened 2D array images = numpy.transpose(images, (1, 0)) preprocess_counter += 1 print("Processed raw image %d" % preprocess_counter) return (images)
# cells_per_block=(3, 3), # visualise=None, transform_sqrt=False, # feature_vector=True)#没看懂 一维矩阵 长度不定 glcm=feature.greycomatrix(r+g+b, [1],[0,np.pi/4,np.pi/2,3*np.pi/4,np.pi], levels=3*256)# greycghg=feature.greycoprops(glcm, prop='homogeneity')/(256*256*9)#size1*5 greycgcl=feature.greycoprops(glcm, prop='correlation')/(256*256*9) greycgeg=feature.greycoprops(glcm, prop='energy')/(256*256*9) greycgasm=feature.greycoprops(glcm, prop='ASM')/(256*256*9) greycgctt=feature.greycoprops(glcm, prop='contrast')/(256*256*9) lbp=feature.local_binary_pattern(imgrey, 8, np.pi/4)#size同图片 plm=feature.peak_local_max(imgrey, min_distance=1)#多个坐标对 st=feature.structure_tensor(imgrey, sigma=1, mode='constant', cval=0)#三个同图片一样大的矩阵 ste=feature.structure_tensor_eigvals(st[0],st[1],st[2])#两个个同图片一样大的矩阵 # hmf=feature.hessian_matrix(image, sigma=1, mode='constant', # cval=0, order=None)#6个三通道的原图大小矩阵 hmd=feature.hessian_matrix_det(imgrey, sigma=1)#原图大小矩阵 # hme=feature.hessian_matrix_eigvals(hmf, Hxy=None, Hyy=None) si=feature.shape_index(imgrey, sigma=1, mode='constant', cval=0)#原图大小矩阵 # ckr=feature.corner_kitchen_rosenfeld(image, mode='constant', cval=0) ##原图大小矩阵 三通道 # ch=feature.corner_harris(imgrey, method='k', k=0.05, eps=1e-06, sigma=1)#原图大小矩阵 # cht=feature.corner_shi_tomasi(imgrey, sigma=1)#原图大小矩阵 # cfs=feature.corner_foerstner(imgrey, sigma=1)#2个 #原图大小矩阵 # csb=feature.corner_subpix(image, ch, window_size=11, alpha=0.99) cps=feature.corner_peaks(imgrey, min_distance=1, threshold_abs=None, threshold_rel=0.1, exclude_border=True, indices=True, footprint=None, labels=None)#一堆坐标值 # cmr=feature.corner_moravec(imgrey, window_size=1)#原图大小矩阵 # cft=feature.corner_fast(imgrey, n=12, threshold=0.15)#原图大小矩阵
from context import data with rio.open(data.naip.lineaments, 'r') as src: image = src.read() # This assumes a grayscale image. For simplicity, we'll just use RGB mean. data = image.astype(float).mean(axis=0) # Compute the structure tensor. This is basically local gradient similarity. # We're getting three components at each pixel that correspond to a 2x2 # symmetric matrix. i.e. [[axx, axy],[axy, ayy]] axx, axy, ayy = structure_tensor(data, sigma=2.5, mode='mirror') # Then we'll compute the eigenvalues of that matrix. v1, v2 = structure_tensor_eigvals(axx, axy, ayy) # And calculate the eigenvector corresponding to the largest eigenvalue. dx, dy = v1 - axx, -axy # We have a vector at each pixel now. However, we don't really care about all # of them, only those with a large magnitude. Also, we don't need to worry # about every pixel, as adjacent values are very highly correlated. Therefore, # let's only consider every 10th pixel in each direction. # Top 10th percentile of magnitude mag = np.hypot(dx, dy) selection = mag > np.percentile(mag, 90) # Every 10th pixel (skipping left edge due to boundary effects) ds = np.zeros_like(selection)
img_mult = img_mult.reshape(img.shape) return img_mult ############# sift = cv2.xfeatures2d.SIFT_create() kp1, des1 = feature.ORB(frame1,None) kp2, des2 = sift.detectAndCompute(frame2,None) ################# def ng_structure_tensor(frame): kernel = np.array([[-3,0,3],[-10,0,10],[-3,0,3]],dtype=np.float)/32. Axx, Axy, Ayy = feature.structure_tensor(frame_sig, sigma=100) l1, l2 = feature.structure_tensor_eigvals(Axx, Axy, Ayy) l1_arr = np.array(l1) l2_arr = np.array(l2) #fig, ax = plt.subplots(3,2) ax[0,0].imshow(frame_sig) ax[1,0].imshow(l1_arr) ax[2,0].imshow(l2_arr) ax[0,1].imshow(Axx) ax[1,1].imshow(Axy) ax[2,1].imshow(Ayy) #### Filtering ellipses import pandas as pd # from a list...
def image_preprocess(filename, nfeatures, original_image_array, sigmas=SIGMAS): x = 0 #simage(original_image_array, "original.tif") images = numpy.empty((nfeatures, original_image_array.size), dtype=numpy.uint8) img = cv2.normalize(original_image_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 for age in AGE_CLASSES: img = label_age(original_image_array, age, filename) #f = "AGE_" + age + ".tif"; simage(img, f) #img = cv2.normalize(img,None,0,255,cv2.NORM_MINMAX,cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 for s in sigmas: # Gaussian Smoothing img = gaussian_filter(original_image_array, sigma=s) #f = "gaussian_smoothing_" + str(s) + ".tif"; simage(img, f) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Sobel Edge Detection img = scipy.ndimage.sobel(original_image_array, mode='constant', cval=s) #f = "sobel_edge_detection_" + str(s) + ".tif"; simage(img, f) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Laplacian of Gaussian Edge Detection img = scipy.ndimage.gaussian_laplace(original_image_array, sigma=s) #f = "laplacian_of_gaussian_edge_detection_" + str(s) + ".tif"; simage(img, f) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Gaussian Gradient Magnitude Edge Detection img = scipy.ndimage.gaussian_gradient_magnitude(original_image_array, sigma=s) #f = "gaussian_gradient_magnitude__edge_detection_" + str(s) + ".tif"; simage(img, f) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Difference of Gaussians k = 1.7 tmp1_array = scipy.ndimage.gaussian_filter(original_image_array, sigma=s * k) tmp2_array = scipy.ndimage.gaussian_filter(original_image_array, sigma=s) img = (tmp1_array - tmp2_array) #f = "difference_of_gaussians_" + str(s) + ".tif"; simage(img, f) img = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Structure Tensor Eigenvalues Axx, Axy, Ayy = feature.structure_tensor( Image.fromarray(original_image_array), sigma=s) large_array, small_array = feature.structure_tensor_eigvals( Axx, Axy, Ayy) #f = "structure_tensor_eigenvalues_large_" + str(s) + ".tif"; simage(large_array, f) #f = "structure_tensor_eigenvalues_small_" + str(s) + ".tif"; simage(small_array, f) img = cv2.normalize(large_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(small_array, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Hessian Matrix Hrr, Hrc, Hcc = feature.hessian_matrix( Image.fromarray(original_image_array), sigma=s, order='rc') #f = "hessian_matrix_Hrr_" + str(s) + ".tif"; simage(Hrr, f) #f = "hessian_matrix_Hrc_" + str(s) + ".tif"; simage(Hrc, f) #f = "hessian_matrix_Hcc_" + str(s) + ".tif"; simage(Hcc, f) img = cv2.normalize(Hrr, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(Hrc, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 img = cv2.normalize(Hcc, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Wang points (radii of 1,3,5,7) newimg = wang_function(original_image_array, radius=1) #f = "wang_points_radius1.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 newimg = wang_function(original_image_array, radius=3) #f = "wang_points_radius3.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 newimg = wang_function(original_image_array, radius=5) #f = "wang_points_radius5.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 newimg = wang_function(original_image_array, radius=7) #f = "wang_points_radius7.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Median Neighborhood compared to overall newimg = median_hood(original_image_array, radius=4, factor=1.0) #f = "median_hood_1.0.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 newimg = median_hood(original_image_array, radius=4, factor=1.25) #f = "median_hood_1.25.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 newimg = median_hood(original_image_array, radius=4, factor=1.5) #f = "median_hood_1.5.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 # Generate proximity map (to center of image) newimg = center_proximity(original_image_array) #f = "center_proximity.tif"; simage(newimg, f) img = cv2.normalize(newimg, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U) images[x] = img.flatten(order='F') x += 1 images = numpy.transpose(images, (1, 0)) print("processed %d features out of %d" % (x, nfeatures)) return (images)