def run(self, ips, snap, img, para = None):
nimg.uniform_filter(snap, para['size'], output=img)
python类uniform_filter()的实例源码
def run(self, ips, imgs, para = None):
imgs[:] = ndimg.uniform_filter(imgs, para['size'])
def filter_data(data, size, no_data_val=None):
"""
This does not work with masked array.
ndimage.uniform_filter does not respect masked array
Parameters
----------
data
size
no_data_val
Returns
-------
"""
if no_data_val:
mask = data == no_data_val
data[mask] = np.nan
averaged_data = np.zeros_like(data)
ndimage.uniform_filter(data,
output=averaged_data,
size=size,
mode='nearest')
return averaged_data
def add_noise(x):
"""Add random noise to images."""
sz = x.shape
mask = (x == 0) * 1.
noise = np.random.rand(sz[0], sz[1])
for i in range(x.shape[0]):
noise[i] = ndimage.uniform_filter(noise[i].reshape(28, 28), size=3).flatten()
noise = np.multiply(noise, mask)
out = np.clip(x + noise, 0., 1.)
return out
def skel_to_graph(skel):
"""
Transform skeleton into its branches and nodes, by counting the number
of neighbors of each pixel in the skeleton
"""
convolve_skel = 3**skel.ndim * ndimage.uniform_filter(skel.astype(np.float)) # 3x3 square mean
neighbors = np.copy(skel.astype(np.uint8))
skel = skel.astype(np.bool)
neighbors[skel] = convolve_skel[skel] - 1
edges = morphology.label(np.logical_or(neighbors == 2, neighbors ==1),
background=0)
nodes = morphology.label(np.logical_and(np.not_equal(neighbors, 2),
neighbors > 0), background=0)
length_edges = np.bincount(edges.ravel())
return nodes, edges, length_edges
def count_neighbors(binary):
convolve = 3**binary.ndim * ndimage.uniform_filter(binary.astype(np.float)) # 3x3 sum
neighbors = np.copy(binary.astype(np.uint8))
binary = binary.astype(np.bool)
neighbors[binary] = convolve[binary] - 1
return neighbors
def _icfmedian(i, stack, weight=None, cfwidth=None):
ufilt = 3 # set this to help with extreme over/under corrections
return ndi.median_filter(
ndi.uniform_filter(stack, (ufilt, 1)), (cfwidth, 1))
def filter_center(data, size=3, no_data_val=None, func=np.nanmean,
mask_no_data=False):
"""
Parameters
----------
data: input data
size: odd number uniform filtering kernel size
no_data_val: value in matrix that is treated as no data value
func: function to use, choose from np.nanmean/median/max/min etc.
mask_no_data: bool, if True will keep the original no data pixel intact
Returns: nanmean of the matrix A filtered by a uniform kernel of size=size
-------
Adapted from: http://stackoverflow.com/questions/23829097/python-numpy-fastest-method-for-2d-kernel-rank-filtering-on-masked-arrays-and-o?rq=1
Notes
-----
This function `centers` the kernel at the target pixel.
This is slightly different from scipy.ndimage.uniform_filter application.
In scipy.ndimage.uniform_filter, a convolution approach is implemented.
An equivalent is scipy.ndimage.uniform_filter like convolution approach
with no_data_val/nan handling can be found in
filter_broadcast_uniform_filter in this module.
Change function to nanmedian, nanmax, nanmin as required.
"""
assert size % 2 == 1, 'Please supply an odd size'
rows, cols = data.shape
padded_data = np.empty(shape=(rows + size-1,
cols + size-1),
dtype=data.dtype)
padded_data[:] = np.nan
rows_pad, cols_pad = padded_data.shape
if no_data_val is not None:
mask = data == no_data_val
data[mask] = np.nan
padded_data[size//2:rows_pad - size//2,
size//2: cols_pad - size//2] = data.copy()
row, col = data.shape
stride_data = as_strided(padded_data, (row, col, size, size),
padded_data.strides+padded_data.strides)
stride_data = stride_data.copy().reshape((row, col, size**2))
avg = func(stride_data, axis=2)
avg[np.isnan(avg)] = no_data_val
if mask_no_data:
avg[mask] = no_data_val
return avg
def filter_uniform_filter(data, size=3, no_data_val=None,
func=np.nanmean):
"""
Parameters
----------
A = input data
size = odd number uniform filtering kernel size
no_data_val = value in matrix that is treated as no data value
Returns: nanmean of the matrix A filtered by a uniform kernel of size=size
-------
Adapted from: http://stackoverflow.com/questions/23829097/python-numpy-fastest-method-for-2d-kernel-rank-filtering-on-masked-arrays-and-o?rq=1
Notes:
This is equivalent to scipy.ndimage.uniform_filter, but can handle nan's,
and can use numpy nanmean/median/max/min functions.
no_data_val/nan handling can be found in filter_broadcast_uniform_filter in
this module.
Change function to nanmeadian, nanmax, nanmin as required.
"""
assert size % 2 == 1, 'Please supply an odd size'
rows, cols = data.shape
padded_A = np.empty(shape=(rows + size-1,
cols + size-1),
dtype=data.dtype)
padded_A[:] = np.nan
rows_pad, cols_pad = padded_A.shape
if no_data_val:
mask = data == no_data_val
data[mask] = np.nan
padded_A[size-1: rows_pad, size - 1: cols_pad] = data.copy()
n, m = data.shape
strided_data = as_strided(padded_A, (n, m, size, size),
padded_A.strides+padded_A.strides)
strided_data = strided_data.copy().reshape((n, m, size**2))
return func(strided_data, axis=2)
def hog_feature(im):
"""Compute Histogram of Gradient (HOG) feature for an image
Modified from skimage.feature.hog
http://pydoc.net/Python/scikits-image/0.4.2/skimage.feature.hog
Reference:
Histograms of Oriented Gradients for Human Detection
Navneet Dalal and Bill Triggs, CVPR 2005
Parameters:
im : an input grayscale or rgb image
Returns:
feat: Histogram of Gradient (HOG) feature
"""
# convert rgb to grayscale if needed
if im.ndim == 3:
image = rgb2gray(im)
else:
image = np.at_least_2d(im)
sx, sy = image.shape # image size
orientations = 9 # number of gradient bins
cx, cy = (8, 8) # pixels per cell
gx = np.zeros(image.shape)
gy = np.zeros(image.shape)
gx[:, :-1] = np.diff(image, n=1, axis=1) # compute gradient on x-direction
gy[:-1, :] = np.diff(image, n=1, axis=0) # compute gradient on y-direction
grad_mag = np.sqrt(gx ** 2 + gy ** 2) # gradient magnitude
grad_ori = np.arctan2(gy, (gx + 1e-15)) * (180 / np.pi) + 90 # gradient orientation
n_cellsx = int(np.floor(sx / cx)) # number of cells in x
n_cellsy = int(np.floor(sy / cy)) # number of cells in y
# compute orientations integral images
orientation_histogram = np.zeros((n_cellsx, n_cellsy, orientations))
for i in range(orientations):
# create new integral image for this orientation
# isolate orientations in this range
temp_ori = np.where(grad_ori < 180 / orientations * (i + 1),
grad_ori, 0)
temp_ori = np.where(grad_ori >= 180 / orientations * i,
temp_ori, 0)
# select magnitudes for those orientations
cond2 = temp_ori > 0
temp_mag = np.where(cond2, grad_mag, 0)
orientation_histogram[:,:,i] = uniform_filter(temp_mag, size=(cx, cy))[cx/2::cx, cy/2::cy].T
return orientation_histogram.ravel()
