lut[msk] = np.arange(1, msk.sum()+1)
mask = lut[lab].ravel()[rst].reshape(shp)
return hist, lut[lab], mask
if __name__ == '__main__':
from skimage.io import imread, imsave
from skimage.data import coins, gravel
from skimage.segmentation import find_boundaries
import matplotlib.pyplot as plt
from time import time
import cellpose
from cellpose import models, utils
img = gravel()
use_GPU = models.use_gpu()
model = models.Cellpose(gpu=use_GPU, model_type='cyto')
channels = [0, 0]
mask, flow, style, diam = model.eval(
img, diameter=30, rescale=None, channels=[0,0])
start = time()
water, core, msk = flow2msk(flow[1].transpose(1,2,0), None, 1.0, 20, 100)
print('flow to mask cost:', time()-start)
ax1, ax2, ax3, ax4, ax5, ax6 =\
[plt.subplot(230+i) for i in (1,2,3,4,5,6)]
ax1.imshow(img)
ax2.imshow(flow[0])
ax3.imshow(np.log(water+1))
ax4.imshow(core)
ax5.imshow(msk)
# prepare filter bank kernels
kernels = []
for theta in range(4):
theta = theta / 4. * np.pi
for sigma in (1, 3):
for frequency in (0.05, 0.25):
kernel = np.real(gabor_kernel(frequency, theta=theta,
sigma_x=sigma, sigma_y=sigma))
kernels.append(kernel)
shrink = (slice(0, None, 3), slice(0, None, 3))
brick = img_as_float(data.brick())[shrink]
grass = img_as_float(data.grass())[shrink]
gravel = img_as_float(data.gravel())[shrink]
image_names = ('brick', 'grass', 'gravel')
images = (brick, grass, gravel)
# prepare reference features
ref_feats = np.zeros((3, len(kernels), 2), dtype=np.double)
ref_feats[0, :, :] = compute_feats(brick, kernels)
ref_feats[1, :, :] = compute_feats(grass, kernels)
ref_feats[2, :, :] = compute_feats(gravel, kernels)
print('Rotated images matched against references using Gabor filter banks:')
print('original: brick, rotated: 30deg, match result: ', end='')
feats = compute_feats(ndi.rotate(brick, angle=190, reshape=False), kernels)
print(image_names[match(feats, ref_feats)])
# Numpy, Scipy, Scikit, OpenCV, Python Image Library(PIL) #An image #Can be represented by a 2D arrays # (each grid/pixel of an array represents a pixel in the image) #A digital image can be classified into 2 types of channels: grayscale, multichannel #Grayscale - only grey shades(different tones of black and white) #Multichannel RGB - has 3 layers (Red, Green, Blue) #About Scikit #Opensource #A Python package #Works with NumPy arrays #To install a package, #pip install scikit-image #or #file -> settings -> project -> + search for the package -> install # Displaying an image from the library itself from skimage import data, io #scikit includes a file with some preloaded images in them(inside the 'data' module) image = data.gravel() #imshow() displays an image io.imshow(image) #show() displays the pending images queued by imshow(used when displaying images from non-interactive shells) io.show()
blurred with a Gaussian kernel from a less-blurred image. This example shows
two applications of the Difference of Gaussians approach for band-pass
filtering.
"""
######################################################################
# Denoise image and reduce shadows
# ================================
import matplotlib.pyplot as plt
import numpy as np
from skimage.data import gravel
from skimage.filters import difference_of_gaussians, window
from scipy.fftpack import fftn, fftshift
image = gravel()
wimage = image * window('hann', image.shape) # window image to improve FFT
filtered_image = difference_of_gaussians(image, 1, 12)
filtered_wimage = filtered_image * window('hann', image.shape)
im_f_mag = fftshift(np.abs(fftn(wimage)))
fim_f_mag = fftshift(np.abs(fftn(filtered_wimage)))
fig, ax = plt.subplots(nrows=2, ncols=2, figsize=(8, 8))
ax[0, 0].imshow(image, cmap='gray')
ax[0, 0].set_title('Original Image')
ax[0, 1].imshow(np.log(im_f_mag), cmap='magma')
ax[0, 1].set_title('Original FFT Magnitude (log)')
ax[1, 0].imshow(filtered_image, cmap='gray')
ax[1, 0].set_title('Filtered Image')
ax[1, 1].imshow(np.log(fim_f_mag), cmap='magma')
ax[1, 1].set_title('Filtered FFT Magnitude (log)')
hist, _ = np.histogram(lbp, density=True, bins=n_bins, range=(0, n_bins))
for name, ref in refs.items():
ref_hist, _ = np.histogram(ref,
density=True,
bins=n_bins,
range=(0, n_bins))
score = kullback_leibler_divergence(hist, ref_hist)
if score < best_score:
best_score = score
best_name = name
return best_name
brick = data.brick()
grass = data.grass()
gravel = data.gravel()
refs = {
'brick': local_binary_pattern(brick, n_points, radius, METHOD),
'grass': local_binary_pattern(grass, n_points, radius, METHOD),
'gravel': local_binary_pattern(gravel, n_points, radius, METHOD)
}
# classify rotated textures
print('Rotated images matched against references using LBP:')
print('original: brick, rotated: 30deg, match result: ',
match(refs, rotate(brick, angle=30, resize=False)))
print('original: brick, rotated: 70deg, match result: ',
match(refs, rotate(brick, angle=70, resize=False)))
print('original: grass, rotated: 145deg, match result: ',
match(refs, rotate(grass, angle=145, resize=False)))
import numpy as np from skimage import data import matplotlib.pyplot as plt import cv2 im = data.gravel() im = im[:128,:128] #Sobel Mask Gx = cv2.Sobel(im,cv2.CV_16S,1,0,ksize=3) Gy = cv2.Sobel(im,cv2.CV_16S,0,1,ksize=3) #Magnitude and Theta M = np.hypot(Gx,Gy) max_m = np.amax(M) theta = np.arctan2(Gy,Gx) print(theta) # Normalization M *= 255 / max_m theta += np.pi theta *= 90 /np.pi print(theta) #create HSV image hsv = np.ndarray((im.shape[0],im.shape[1],3),dtype=np.uint8) hsv[:,:,0] = theta hsv[:,:,1] = np.full((im.shape[0],im.shape[1]),255) hsv[:,:,2] = M out = cv2.cvtColor(hsv,cv2.COLOR_HSV2RGB) plt.imshow(out)
