def create_pyramid(I, layer_num=5, downscale=2): # create a image pyramid I_py_temp = tuple(pyramid_gaussian(\ I[0,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) I_lap_py_temp = tuple(pyramid_laplacian(\ I[0,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) I_py = [] I_lap_py = [] for i in range(layer_num): I_py.append( np.empty( ( (I.shape[0],)+ I_py_temp[i].shape ) ) ) I_lap_py.append( np.empty( ( (I.shape[0],)+ I_lap_py_temp[i].shape ) ) ) for i in range(I.shape[0]): I_py_temp = tuple(pyramid_gaussian(\ I[i,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) I_lap_py_temp = tuple(pyramid_laplacian(\ I[i,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) for j in range(layer_num): I_py[j][i,:,:,:] = I_py_temp[j] I_lap_py[j][i,:,:,:] = I_lap_py_temp[j] return I_py, I_lap_py
def test_build_laplacian_pyramid(): rows, cols, dim = image.shape pyramid = pyramid_laplacian(image, downscale=2) for layer, out in enumerate(pyramid): layer_shape = (rows / 2 ** layer, cols / 2 ** layer, dim) assert_array_equal(out.shape, layer_shape)
def test_build_laplacian_pyramid(): rows, cols, dim = image.shape pyramid = pyramid_laplacian(image, downscale=2) for layer, out in enumerate(pyramid): layer_shape = (rows / 2**layer, cols / 2**layer, dim) assert_array_equal(out.shape, layer_shape)
def Laplacian_pyramid(I, n, s=3): # 拉普拉斯金字塔 gau = [] for (i, resized) in enumerate(pyramid_laplacian(I, downscale=2, sigma=s)): if i == n: break gau.append(resized) return gau
def laplacian(self, base: np.ndarray) -> List[np.ndarray]: """Downsample using :func:`skimage.transform.pyramid_laplacian`.""" return list( pyramid_laplacian( base, downscale=self.downscale, max_layer=self.max_layer, multichannel=False, ))
def laplace_pyramids(dataset, levels=4): pyramids = [[] for _ in range(levels)] for img in dataset: pyramid = transform.pyramid_laplacian(img, max_layer=levels - 1, multichannel=False) for i, img_level in enumerate(pyramid): pyramids[i].append(img_level) return pyramids
def main(argv): filename = argv[1] img = io.imread(filename, as_grey=True) lpyra = tuple(transform.pyramid_laplacian(img)) l = lpyra[0] l = exposure.equalize_hist(l) y, x = np.indices((l.shape[0],l.shape[1])) vect = np.array(zip(y.reshape(y.size),x.reshape(x.size),l.reshape(l.size))) io.imshow(l) io.show()
def laplacian_downsample(frames, pyramid_levels=4): nt = frames.shape[0] for ii, frame in enumerate(frames): pyr = transform.pyramid_laplacian(frame.astype(np.float)) for jj in xrange(pyramid_levels + 1): ds = pyr.next() if ii == 0: out = np.empty((nt,) + ds.shape, dtype=np.float) out[ii] = ds return out
def create_pyramid_tuple(I, layer_num=5, downscale=2): # return the pyramid as a list of tuples I_py = [] I_lap_py = [] for i in range(I.shape[0]): I_py.append( tuple(pyramid_gaussian(\ I[i,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) ) I_lap_py.append( tuple(pyramid_laplacian(\ I[i,:,:,:], \ max_layer=layer_num-1, \ downscale=downscale )) ) return I_py, I_lap_py
def loopback(image, scales=3, A=None, pyramid=None): """ Generate laplacian pyramid and return reconstructred matrix from generative matrices """ base_image_side = image.shape[0] base_image_dim = base_image_side**2 if pyramid == None: pyramid = tuple(pyramid_laplacian(image, downscale=2, max_layer=scales-1, mode='constant', order=5)) if A == None: A = laplacianGenerative(base_image_dim, scales) recon = np.zeros((base_image_dim,1)) for s in range(scales): image_dim = int(base_image_dim/4**s) recon += A[s].T.dot(pyramid[s].reshape((image_dim,1))) return recon
def blob_stats(im, show_images=False): if im.shape != (64, 64): im = transform.resize(im, (64, 64)) pyramid = tuple(transform.pyramid_laplacian(im, mode='nearest')) num_blobs = [] for idx in range(4): dist = np.ceil(8.0 / (3.0 * (idx+1))) maxms = feature.peak_local_max(pyramid[idx], min_distance=dist) if maxms == []: num_blobs.append(0) continue num_blobs.append(maxms.shape[0]) if show_images: plt.subplot(4, 2, 2*idx + 1) plt.imshow(im, cmap='gray') plt.scatter(maxms.T[1] * (2**idx), maxms.T[0] * (2**idx), s=50, c='g') plt.subplot(4, 2, 2*idx + 2) plt.imshow(pyramid[idx], cmap='gray') plt.scatter(maxms.T[1], maxms.T[0], s=50, c='g') if show_images: plt.show() return num_blobs
def laplacian(image_dim=32 * 32, scales=3, normalize=False, plot=False, images='vanhateran', num_patches=4000): # Generate Laplacian pyramids from data set image_side = math.sqrt(image_dim) if images == 'vanhateran': IMAGES = preprocess.extract_patches(images='vanhateran', num_images=num_patches, image_dim=image_dim) elif images == 'berkeley': IMAGES = np.zeros((image_side, image_side, num_patches)) FIMAGES = scipy.io.loadmat('../../images/IMAGES.mat') FIMAGES = FIMAGES['IMAGES'] (full_image_size, full_image_size, full_num_patches) = FIMAGES.shape BUFF = 4 for i in range(num_patches): imi = np.floor(full_num_patches * random.uniform(0, 1)) r = BUFF + np.ceil((full_image_size - image_side - 2 * BUFF) * random.uniform(0, 1)) c = BUFF + np.ceil((full_image_size - image_side - 2 * BUFF) * random.uniform(0, 1)) IMAGES[i, :, :] = FIMAGES[r:r + image_side, c:c + image_side, imi] elif images == 'cifar': def unpickle(file): # Open CIFAR files import cPickle fo = open(file, 'rb') dict = cPickle.load(fo) fo.close() return dict data = 'data_batch_1' cifar = unpickle('./data/cifar-10/' + data) IMAGES = cifar['data'].T IMAGES = IMAGES - np.mean(IMAGES, axis=0) # Mean subtract pyramids = [] I = tuple([ np.zeros((num_patches, image_dim / (2 * 2)**s)) for s in range(scales) ]) #I = np.empty((image_dim, scales, num_patches)) for i in range(num_patches): pyramids.append( tuple( pyramid_laplacian(IMAGES[i, :, :], downscale=2, max_layer=scales - 1))) if normalize == True: for s in range(scales): temp = pyramids[i][s].reshape((image_dim / (2 * 2)**s)) norm = float(sqrt(np.sum(temp**2))) if norm != 0: I[s][i, :image_dim / (2 * 2)**s] = temp / norm else: I[s][i, :image_dim / (2 * 2)**s] = temp else: for s in range(scales): I[s][i, :image_dim / (2 * 2)**s] = pyramids[i][s].reshape( (image_dim / (2 * 2)**s)) if plot: fig, ax = plt.subplots(scales + 1) ax[0].imshow(IMAGES[1, :, :], cmap='Greys', vmin=np.min(IMAGES[1, :, :]), vmax=np.max(IMAGES[1, :, :]), interpolation='nearest') for i in range(1, 4): ax[i].imshow(I[1, :, i - 1].reshape(image_side, image_side), vmin=np.min(I[1, :, i - 1]), vmax=np.max(I[1, :, i - 1]), cmap='Greys', interpolation='nearest') return I
def gauss_subsample(im, depth): pyramid = [im] for _ in range(depth - 1): conv = convolve2d(pyramid[-1], K_gauss, mode='same') # .astype('uint8') pyramid.append(conv[::2, ::2]) return pyramid def laplace_subsample(im, depth): return [(img - convolve2d(img, K_gauss, mode='same')) for img in gauss_subsample(im, depth)] fix, axs = plt.subplots(4, 4) for idx, im in enumerate( zip(gauss_subsample(I, 4), pyramid_gaussian(I, max_layer=3, sigma=1), laplace_subsample(I, 4), pyramid_laplacian(I, max_layer=3, sigma=1))): axs[0, idx].imshow(im[0], cmap='gray') axs[1, idx].imshow(im[1], cmap='gray') axs[2, idx].imshow(im[2], cmap='gray') axs[3, idx].imshow(im[3], cmap='gray') axs[0, 0].set_title('Own Gaussian') axs[1, 0].set_title('skimage Gaussian') axs[2, 0].set_title('Own Laplacian') axs[3, 0].set_title('skimage Laplacian') plt.show()