filters.rank
¶skimage.filters.rank.autolevel (image, selem) 
Autolevel image using local histogram. 
skimage.filters.rank.autolevel_percentile (…) 
Return greyscale local autolevel of an image. 
skimage.filters.rank.bottomhat (image, selem) 
Local bottomhat of an image. 
skimage.filters.rank.enhance_contrast (image, …) 
Enhance contrast of an image. 
skimage.filters.rank.enhance_contrast_percentile (…) 
Enhance contrast of an image. 
skimage.filters.rank.entropy (image, selem[, …]) 
Local entropy. 
skimage.filters.rank.equalize (image, selem) 
Equalize image using local histogram. 
skimage.filters.rank.geometric_mean (image, selem) 
Return local geometric mean of an image. 
skimage.filters.rank.gradient (image, selem) 
Return local gradient of an image (i.e. 
skimage.filters.rank.gradient_percentile (…) 
Return local gradient of an image (i.e. 
skimage.filters.rank.maximum (image, selem[, …]) 
Return local maximum of an image. 
skimage.filters.rank.mean (image, selem[, …]) 
Return local mean of an image. 
skimage.filters.rank.mean_bilateral (image, selem) 
Apply a flat kernel bilateral filter. 
skimage.filters.rank.mean_percentile (image, …) 
Return local mean of an image. 
skimage.filters.rank.median (image[, selem, …]) 
Return local median of an image. 
skimage.filters.rank.minimum (image, selem[, …]) 
Return local minimum of an image. 
skimage.filters.rank.modal (image, selem[, …]) 
Return local mode of an image. 
skimage.filters.rank.noise_filter (image, selem) 
Noise feature. 
skimage.filters.rank.otsu (image, selem[, …]) 
Local Otsu’s threshold value for each pixel. 
skimage.filters.rank.percentile (image, selem) 
Return local percentile of an image. 
skimage.filters.rank.pop (image, selem[, …]) 
Return the local number (population) of pixels. 
skimage.filters.rank.pop_bilateral (image, selem) 
Return the local number (population) of pixels. 
skimage.filters.rank.pop_percentile (image, selem) 
Return the local number (population) of pixels. 
skimage.filters.rank.subtract_mean (image, selem) 
Return image subtracted from its local mean. 
skimage.filters.rank.subtract_mean_percentile (…) 
Return image subtracted from its local mean. 
skimage.filters.rank.sum (image, selem[, …]) 
Return the local sum of pixels. 
skimage.filters.rank.sum_bilateral (image, selem) 
Apply a flat kernel bilateral filter. 
skimage.filters.rank.sum_percentile (image, selem) 
Return the local sum of pixels. 
skimage.filters.rank.threshold (image, selem) 
Local threshold of an image. 
skimage.filters.rank.threshold_percentile (…) 
Local threshold of an image. 
skimage.filters.rank.tophat (image, selem[, …]) 
Local tophat of an image. 
skimage.filters.rank.windowed_histogram (…) 
Normalized sliding window histogram 
skimage.filters.rank.bilateral 
Approximate bilateral rank filter for local (custom kernel) mean. 
skimage.filters.rank.bilateral_cy 

skimage.filters.rank.core_cy 

skimage.filters.rank.generic 
General Description 
skimage.filters.rank.generic_cy 

skimage.filters.rank.percentile_cy 
skimage.filters.rank.
autolevel
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Autolevel image using local histogram.
This filter locally stretches the histogram of greyvalues to cover the entire range of values from “white” to “black”.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import autolevel
>>> img = data.camera()
>>> auto = autolevel(img, disk(5))
skimage.filters.rank.
autolevel_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return greyscale local autolevel of an image.
This filter locally stretches the histogram of greyvalues to cover the entire range of values from “white” to “black”.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
bottomhat
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Local bottomhat of an image.
This filter computes the morphological closing of the image and then subtracts the result from the original image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : 2D array
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import bottomhat
>>> img = data.camera()
>>> out = bottomhat(img, disk(5))
skimage.filters.rank.
enhance_contrast
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Enhance contrast of an image.
This replaces each pixel by the local maximum if the pixel greyvalue is closer to the local maximum than the local minimum. Otherwise it is replaced by the local minimum.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
Returns
out : 2D array (same dtype as input image)


Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import enhance_contrast
>>> img = data.camera()
>>> out = enhance_contrast(img, disk(5))
skimage.filters.rank.
enhance_contrast_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Enhance contrast of an image.
This replaces each pixel by the local maximum if the pixel greyvalue is closer to the local maximum than the local minimum. Otherwise it is replaced by the local minimum.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
entropy
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Local entropy.
The entropy is computed using base 2 logarithm i.e. the filter returns the minimum number of bits needed to encode the local greylevel distribution.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : ndarray (double)

References
[R281]  http://en.wikipedia.org/wiki/Entropy_(information_theory) 
Examples
>>> from skimage import data
>>> from skimage.filters.rank import entropy
>>> from skimage.morphology import disk
>>> img = data.camera()
>>> ent = entropy(img, disk(5))
skimage.filters.rank.
equalize
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Equalize image using local histogram.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import equalize
>>> img = data.camera()
>>> equ = equalize(img, disk(5))
skimage.filters.rank.
geometric_mean
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local geometric mean of an image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

References
[R282]  Gonzalez, R. C. and Wood, R. E. “Digital Image Processing (3rd Edition).” PrenticeHall Inc, 2006. 
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import mean
>>> img = data.camera()
>>> avg = geometric_mean(img, disk(5))
skimage.filters.rank.
gradient
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local gradient of an image (i.e. local maximum  local minimum).
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import gradient
>>> img = data.camera()
>>> out = gradient(img, disk(5))
skimage.filters.rank.
gradient_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return local gradient of an image (i.e. local maximum  local minimum).
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
maximum
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local maximum of an image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

See also
Notes
The lower algorithm complexity makes skimage.filters.rank.maximum more efficient for larger images and structuring elements.
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import maximum
>>> img = data.camera()
>>> out = maximum(img, disk(5))
skimage.filters.rank.
mean
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local mean of an image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import mean
>>> img = data.camera()
>>> avg = mean(img, disk(5))
skimage.filters.rank.
mean_bilateral
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, s0=10, s1=10)[source]¶Apply a flat kernel bilateral filter.
This is an edgepreserving and noise reducing denoising filter. It averages pixels based on their spatial closeness and radiometric similarity.
Spatial closeness is measured by considering only the local pixel neighborhood given by a structuring element.
Radiometric similarity is defined by the greylevel interval [gs0, g+s1] where g is the current pixel greylevel.
Only pixels belonging to the structuring element and having a greylevel inside this interval are averaged.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
s0, s1 : int


Returns:  out : 2D array (same dtype as input image)

See also
skimage.filters.denoise_bilateral
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import mean_bilateral
>>> img = data.camera().astype(np.uint16)
>>> bilat_img = mean_bilateral(img, disk(20), s0=10,s1=10)
skimage.filters.rank.
mean_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return local mean of an image.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
median
(image, selem=None, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local median of an image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array, optional
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import median
>>> img = data.camera()
>>> med = median(img, disk(5))
skimage.filters.rank.
minimum
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local minimum of an image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

See also
Notes
The lower algorithm complexity makes skimage.filters.rank.minimum more efficient for larger images and structuring elements.
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import minimum
>>> img = data.camera()
>>> out = minimum(img, disk(5))
skimage.filters.rank.
modal
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return local mode of an image.
The mode is the value that appears most often in the local histogram.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import modal
>>> img = data.camera()
>>> out = modal(img, disk(5))
skimage.filters.rank.
noise_filter
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Noise feature.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

References
[R283]  N. Hashimoto et al. Referenceless image quality evaluation for whole slide imaging. J Pathol Inform 2012;3:9. 
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import noise_filter
>>> img = data.camera()
>>> out = noise_filter(img, disk(5))
skimage.filters.rank.
otsu
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Local Otsu’s threshold value for each pixel.
Parameters:  image : ndarray
selem : 2D array
out : ndarray
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

References
[R284]  http://en.wikipedia.org/wiki/Otsu’s_method 
Examples
>>> from skimage import data
>>> from skimage.filters.rank import otsu
>>> from skimage.morphology import disk
>>> img = data.camera()
>>> local_otsu = otsu(img, disk(5))
>>> thresh_image = img >= local_otsu
skimage.filters.rank.
percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0)[source]¶Return local percentile of an image.
Returns the value of the p0 lower percentile of the local greyvalue distribution.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
pop
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return the local number (population) of pixels.
The number of pixels is defined as the number of pixels which are included in the structuring element and the mask.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage.morphology import square
>>> import skimage.filters.rank as rank
>>> img = 255 * np.array([[0, 0, 0, 0, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> rank.pop(img, square(3))
array([[4, 6, 6, 6, 4],
[6, 9, 9, 9, 6],
[6, 9, 9, 9, 6],
[6, 9, 9, 9, 6],
[4, 6, 6, 6, 4]], dtype=uint8)
skimage.filters.rank.
pop_bilateral
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, s0=10, s1=10)[source]¶Return the local number (population) of pixels.
The number of pixels is defined as the number of pixels which are included in the structuring element and the mask. Additionally pixels must have a greylevel inside the interval [gs0, g+s1] where g is the greyvalue of the center pixel.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
s0, s1 : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage.morphology import square
>>> import skimage.filters.rank as rank
>>> img = 255 * np.array([[0, 0, 0, 0, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint16)
>>> rank.pop_bilateral(img, square(3), s0=10, s1=10)
array([[3, 4, 3, 4, 3],
[4, 4, 6, 4, 4],
[3, 6, 9, 6, 3],
[4, 4, 6, 4, 4],
[3, 4, 3, 4, 3]], dtype=uint16)
skimage.filters.rank.
pop_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return the local number (population) of pixels.
The number of pixels is defined as the number of pixels which are included in the structuring element and the mask.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
subtract_mean
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return image subtracted from its local mean.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import subtract_mean
>>> img = data.camera()
>>> out = subtract_mean(img, disk(5))
skimage.filters.rank.
subtract_mean_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return image subtracted from its local mean.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
sum
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Return the local sum of pixels.
Note that the sum may overflow depending on the data type of the input array.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage.morphology import square
>>> import skimage.filters.rank as rank
>>> img = np.array([[0, 0, 0, 0, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> rank.sum(img, square(3))
array([[1, 2, 3, 2, 1],
[2, 4, 6, 4, 2],
[3, 6, 9, 6, 3],
[2, 4, 6, 4, 2],
[1, 2, 3, 2, 1]], dtype=uint8)
skimage.filters.rank.
sum_bilateral
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, s0=10, s1=10)[source]¶Apply a flat kernel bilateral filter.
This is an edgepreserving and noise reducing denoising filter. It averages pixels based on their spatial closeness and radiometric similarity.
Spatial closeness is measured by considering only the local pixel neighborhood given by a structuring element (selem).
Radiometric similarity is defined by the greylevel interval [gs0, g+s1] where g is the current pixel greylevel.
Only pixels belonging to the structuring element AND having a greylevel inside this interval are summed.
Note that the sum may overflow depending on the data type of the input array.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
s0, s1 : int


Returns:  out : 2D array (same dtype as input image)

See also
skimage.filters.denoise_bilateral
Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import sum_bilateral
>>> img = data.camera().astype(np.uint16)
>>> bilat_img = sum_bilateral(img, disk(10), s0=10, s1=10)
skimage.filters.rank.
sum_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0, p1=1)[source]¶Return the local sum of pixels.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Note that the sum may overflow depending on the data type of the input array.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0, p1 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
threshold
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Local threshold of an image.
The resulting binary mask is True if the greyvalue of the center pixel is greater than the local mean.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage.morphology import square
>>> from skimage.filters.rank import threshold
>>> img = 255 * np.array([[0, 0, 0, 0, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 1, 1, 1, 0],
... [0, 0, 0, 0, 0]], dtype=np.uint8)
>>> threshold(img, square(3))
array([[0, 0, 0, 0, 0],
[0, 1, 1, 1, 0],
[0, 1, 0, 1, 0],
[0, 1, 1, 1, 0],
[0, 0, 0, 0, 0]], dtype=uint8)
skimage.filters.rank.
threshold_percentile
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, p0=0)[source]¶Local threshold of an image.
The resulting binary mask is True if the greyvalue of the center pixel is greater than the local mean.
Only greyvalues between percentiles [p0, p1] are considered in the filter.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int
p0 : float in [0, …, 1]


Returns:  out : 2D array (same dtype as input image)

skimage.filters.rank.
tophat
(image, selem, out=None, mask=None, shift_x=False, shift_y=False)[source]¶Local tophat of an image.
This filter computes the morphological opening of the image and then subtracts the result from the original image.
Parameters:  image : 2D array (uint8, uint16)
selem : 2D array
out : 2D array (same dtype as input)
mask : ndarray
shift_x, shift_y : int


Returns:  out : 2D array (same dtype as input image)

Examples
>>> from skimage import data
>>> from skimage.morphology import disk
>>> from skimage.filters.rank import tophat
>>> img = data.camera()
>>> out = tophat(img, disk(5))
skimage.filters.rank.
windowed_histogram
(image, selem, out=None, mask=None, shift_x=False, shift_y=False, n_bins=None)[source]¶Normalized sliding window histogram
Parameters:  image : ndarray
selem : 2D array
out : ndarray
mask : ndarray
shift_x, shift_y : int
n_bins : int or None


Returns:  out : 3D array with float dtype of dimensions (H,W,N), where (H,W) are

Examples
>>> from skimage import data
>>> from skimage.filters.rank import windowed_histogram
>>> from skimage.morphology import disk
>>> img = data.camera()
>>> hist_img = windowed_histogram(img, disk(5))