diff --git a/skimage/filter/rank/_crank16.pyx b/skimage/filter/rank/_crank16.pyx index ab5b6015..602a60f4 100644 --- a/skimage/filter/rank/_crank16.pyx +++ b/skimage/filter/rank/_crank16.pyx @@ -6,18 +6,19 @@ import numpy as np cimport numpy as np from libc.math cimport log2 - -# import main loop from skimage.filter.rank._core16 cimport _core16 + # ----------------------------------------------------------------- # kernels uint16 take extra parameter for defining the bitdepth # ----------------------------------------------------------------- -cdef inline np.uint16_t kernel_autolevel( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_autolevel(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax, delta if pop: @@ -31,27 +32,30 @@ cdef inline np.uint16_t kernel_autolevel( break delta = imax - imin if delta > 0: - return < np.uint16_t > (1. * (maxbin - 1) * (g - imin) / delta) + return (1. * (maxbin - 1) * (g - imin) / delta) else: - return < np.uint16_t > (imax - imin) + return (imax - imin) -cdef inline np.uint16_t kernel_bottomhat( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_bottomhat(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i for i in range(maxbin): if histo[i]: break - return < np.uint16_t > (g - i) + return (g - i) -cdef inline np.uint16_t kernel_equalize( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_equalize(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float sum = 0. @@ -61,14 +65,16 @@ cdef inline np.uint16_t kernel_equalize( if i >= g: break - return < np.uint16_t > (((maxbin - 1) * sum) / pop) + return (((maxbin - 1) * sum) / pop) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_gradient( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_gradient(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax if pop: @@ -80,55 +86,63 @@ cdef inline np.uint16_t kernel_gradient( if histo[i]: imin = i break - return < np.uint16_t > (imax - imin) + return (imax - imin) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_maximum( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_maximum(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i if pop: for i in range(maxbin - 1, -1, -1): if histo[i]: - return < np.uint16_t > (i) + return (i) - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_mean( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_mean(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. if pop: for i in range(maxbin): mean += histo[i] * i - return < np.uint16_t > (mean / pop) + return (mean / pop) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_meansubstraction( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_meansubstraction(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. if pop: for i in range(maxbin): mean += histo[i] * i - return < np.uint16_t > ((g - mean / pop) / 2. + (midbin - 1)) + return ((g - mean / pop) / 2. + (midbin - 1)) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_median( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_median(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float sum = pop / 2.0 @@ -137,27 +151,31 @@ cdef inline np.uint16_t kernel_median( if histo[i]: sum -= histo[i] if sum < 0: - return < np.uint16_t > (i) + return (i) - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_minimum( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_minimum(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i if pop: for i in range(maxbin): if histo[i]: - return < np.uint16_t > (i) + return (i) - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_modal( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_modal(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t hmax = 0, imax = 0 if pop: @@ -165,14 +183,16 @@ cdef inline np.uint16_t kernel_modal( if histo[i] > hmax: hmax = histo[i] imax = i - return < np.uint16_t > (imax) + return (imax) - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_morph_contr_enh( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax if pop: @@ -185,49 +205,56 @@ cdef inline np.uint16_t kernel_morph_contr_enh( imin = i break if imax - g < g - imin: - return < np.uint16_t > (imax) + return (imax) else: - return < np.uint16_t > (imin) + return (imin) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_pop( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): - return < np.uint16_t > (pop) -cdef inline np.uint16_t kernel_threshold( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_pop(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): + return (pop) + + +cdef inline np.uint16_t kernel_threshold(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. if pop: for i in range(maxbin): mean += histo[i] * i - return < np.uint16_t > (g > (mean / pop)) + return (g > (mean / pop)) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_tophat( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_tophat(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i for i in range(maxbin - 1, -1, -1): if histo[i]: break - return < np.uint16_t > (i - g) + return (i - g) -cdef inline np.uint16_t kernel_entropy( - Py_ssize_t * histo, float pop, np.uint16_t g, - Py_ssize_t bitdepth, Py_ssize_t maxbin, Py_ssize_t midbin, - float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_entropy(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float e,p @@ -238,7 +265,7 @@ cdef inline np.uint16_t kernel_entropy( if p>0: e -= p*log2(p) - return < np.uint16_t > e*1000 + return e*1000 # ----------------------------------------------------------------- diff --git a/skimage/filter/rank/_crank16_bilateral.pyx b/skimage/filter/rank/_crank16_bilateral.pyx index cf68115e..1fb81a2d 100644 --- a/skimage/filter/rank/_crank16_bilateral.pyx +++ b/skimage/filter/rank/_crank16_bilateral.pyx @@ -5,18 +5,19 @@ import numpy as np cimport numpy as np - -# import main loop from skimage.filter.rank._core16 cimport _core16 + # ----------------------------------------------------------------- # kernels uint16 take extra parameter for defining the bitdepth # ----------------------------------------------------------------- -cdef inline np.uint16_t kernel_mean( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_mean(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, bilat_pop = 0 cdef float mean = 0. @@ -27,16 +28,18 @@ cdef inline np.uint16_t kernel_mean( bilat_pop += histo[i] mean += histo[i] * i if bilat_pop: - return < np.uint16_t > (mean / bilat_pop) + return (mean / bilat_pop) else: - return < np.uint16_t > (0) + return (0) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_pop( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, Py_ssize_t maxbin, - Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_pop(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, bilat_pop = 0 @@ -44,14 +47,16 @@ cdef inline np.uint16_t kernel_pop( for i in range(maxbin): if (g > (i - s0)) and (g < (i + s1)): bilat_pop += histo[i] - return < np.uint16_t > (bilat_pop) + return (bilat_pop) else: - return < np.uint16_t > (0) + return (0) # ----------------------------------------------------------------- # python wrappers # ----------------------------------------------------------------- + + def mean(np.ndarray[np.uint16_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] selem, np.ndarray[np.uint8_t, ndim=2] mask=None, @@ -68,7 +73,8 @@ def pop(np.ndarray[np.uint16_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] mask=None, np.ndarray[np.uint16_t, ndim=2] out=None, char shift_x=0, char shift_y=0, int bitdepth=8, int s0=1, int s1=1): - """returns the number of actual pixels of the structuring element inside the mask + """returns the number of actual pixels of the structuring element inside + the mask """ _core16(kernel_pop, image, selem, mask, out, shift_x, shift_y, bitdepth, .0, .0, s0, s1) diff --git a/skimage/filter/rank/_crank16_percentiles.pyx b/skimage/filter/rank/_crank16_percentiles.pyx index 3b50c86c..4c2525be 100644 --- a/skimage/filter/rank/_crank16_percentiles.pyx +++ b/skimage/filter/rank/_crank16_percentiles.pyx @@ -5,17 +5,19 @@ import numpy as np cimport numpy as np - -# import main loop from skimage.filter.rank._core16 cimport _core16, int_min, int_max + # ----------------------------------------------------------------- # kernels uint16 (SOFT version using percentiles) # ----------------------------------------------------------------- -cdef inline np.uint16_t kernel_autolevel( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_autolevel(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta @@ -36,16 +38,19 @@ cdef inline np.uint16_t kernel_autolevel( delta = imax - imin if delta > 0: - return < np.uint16_t > (1.0 * (maxbin - 1) * (int_min(int_max(imin, g), imax) - imin) / delta) + return (1.0 * (maxbin - 1) \ + * (int_min(int_max(imin, g), imax) - imin) / delta) else: - return < np.uint16_t > (imax - imin) + return (imax - imin) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_gradient( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_gradient(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta @@ -64,14 +69,16 @@ cdef inline np.uint16_t kernel_gradient( imax = i break - return < np.uint16_t > (imax - imin) + return (imax - imin) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_mean( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint16_t kernel_mean(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, mean, n @@ -86,15 +93,18 @@ cdef inline np.uint16_t kernel_mean( mean += histo[i] * i if n > 0: - return < np.uint16_t > (1.0 * mean / n) + return (1.0 * mean / n) else: - return < np.uint16_t > (0) + return (0) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_mean_substraction( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_mean_substraction(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, mean, n @@ -108,15 +118,18 @@ cdef inline np.uint16_t kernel_mean_substraction( n += histo[i] mean += histo[i] * i if n > 0: - return < np.uint16_t > ((g - (mean / n)) * .5 + midbin) + return ((g - (mean / n)) * .5 + midbin) else: - return < np.uint16_t > (0) + return (0) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_morph_contr_enh( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta @@ -135,19 +148,22 @@ cdef inline np.uint16_t kernel_morph_contr_enh( imax = i break if g > imax: - return < np.uint16_t > imax + return imax if g < imin: - return < np.uint16_t > imin + return imin if imax - g < g - imin: - return < np.uint16_t > imax + return imax else: - return < np.uint16_t > imin + return imin else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_percentile( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_percentile(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i cdef float sum = 0. @@ -158,13 +174,16 @@ cdef inline np.uint16_t kernel_percentile( if sum >= p0 * pop: break - return < np.uint16_t > (i) + return (i) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_pop( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_pop(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, n @@ -175,13 +194,16 @@ cdef inline np.uint16_t kernel_pop( sum += histo[i] if (sum >= p0 * pop) and (sum <= p1 * pop): n += histo[i] - return < np.uint16_t > (n) + return (n) else: - return < np.uint16_t > (0) + return (0) -cdef inline np.uint16_t kernel_threshold( - Py_ssize_t * histo, float pop, np.uint16_t g, Py_ssize_t bitdepth, - Py_ssize_t maxbin, Py_ssize_t midbin, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint16_t kernel_threshold(Py_ssize_t * histo, float pop, + np.uint16_t g, Py_ssize_t bitdepth, + Py_ssize_t maxbin, Py_ssize_t midbin, + float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i cdef float sum = 0. @@ -192,9 +214,10 @@ cdef inline np.uint16_t kernel_threshold( if sum >= p0 * pop: break - return < np.uint16_t > ((maxbin - 1) * (g >= i)) + return ((maxbin - 1) * (g >= i)) else: - return < np.uint16_t > (0) + return (0) + # ----------------------------------------------------------------- # python wrappers diff --git a/skimage/filter/rank/_crank8.pyx b/skimage/filter/rank/_crank8.pyx index 5b2cba01..7398b26f 100644 --- a/skimage/filter/rank/_crank8.pyx +++ b/skimage/filter/rank/_crank8.pyx @@ -5,19 +5,18 @@ import numpy as np cimport numpy as np - from libc.math cimport log2 - -# import main loop from skimage.filter.rank._core8 cimport _core8 + # ----------------------------------------------------------------- # kernels uint8 # ----------------------------------------------------------------- -cdef inline np.uint8_t kernel_autolevel( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_autolevel(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax, delta @@ -32,15 +31,16 @@ cdef inline np.uint8_t kernel_autolevel( break delta = imax - imin if delta > 0: - return < np.uint8_t > (255. * (g - imin) / delta) + return (255. * (g - imin) / delta) else: - return < np.uint8_t > (imax - imin) + return (imax - imin) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_bottomhat( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_bottomhat(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i @@ -48,12 +48,12 @@ cdef inline np.uint8_t kernel_bottomhat( if histo[i]: break - return < np.uint8_t > (g - i) + return (g - i) -cdef inline np.uint8_t kernel_equalize( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): +cdef inline np.uint8_t kernel_equalize(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float sum = 0. @@ -64,13 +64,14 @@ cdef inline np.uint8_t kernel_equalize( if i >= g: break - return < np.uint8_t > ((255 * sum) / pop) + return ((255 * sum) / pop) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_gradient( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_gradient(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax @@ -83,26 +84,28 @@ cdef inline np.uint8_t kernel_gradient( if histo[i]: imin = i break - return < np.uint8_t > (imax - imin) + return (imax - imin) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_maximum( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_maximum(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i if pop: for i in range(255, -1, -1): if histo[i]: - return < np.uint8_t > (i) + return (i) - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_mean( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_mean(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. @@ -110,13 +113,14 @@ cdef inline np.uint8_t kernel_mean( if pop: for i in range(256): mean += histo[i] * i - return < np.uint8_t > (mean / pop) + return (mean / pop) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_meansubstraction( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_meansubstraction(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. @@ -124,13 +128,14 @@ cdef inline np.uint8_t kernel_meansubstraction( if pop: for i in range(256): mean += histo[i] * i - return < np.uint8_t > ((g - mean / pop) / 2. + 127) + return ((g - mean / pop) / 2. + 127) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_median( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_median(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float sum = pop / 2.0 @@ -140,25 +145,28 @@ cdef inline np.uint8_t kernel_median( if histo[i]: sum -= histo[i] if sum < 0: - return < np.uint8_t > (i) + return (i) - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_minimum( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_minimum(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i if pop: for i in range(256): if histo[i]: - return < np.uint8_t > (i) + return (i) - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_modal( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_modal(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t hmax = 0, imax = 0 @@ -167,13 +175,14 @@ cdef inline np.uint8_t kernel_modal( if histo[i] > hmax: hmax = histo[i] imax = i - return < np.uint8_t > (imax) + return (imax) - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_morph_contr_enh( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i, imin, imax @@ -187,21 +196,23 @@ cdef inline np.uint8_t kernel_morph_contr_enh( imin = i break if imax - g < g - imin: - return < np.uint8_t > (imax) + return (imax) else: - return < np.uint8_t > (imin) + return (imin) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_pop( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): - return < np.uint8_t > (pop) +cdef inline np.uint8_t kernel_pop(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): -cdef inline np.uint8_t kernel_threshold( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + return (pop) + + +cdef inline np.uint8_t kernel_threshold(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float mean = 0. @@ -209,13 +220,14 @@ cdef inline np.uint8_t kernel_threshold( if pop: for i in range(256): mean += histo[i] * i - return < np.uint8_t > (g > (mean / pop)) + return (g > (mean / pop)) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_tophat( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_tophat(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i @@ -223,64 +235,64 @@ cdef inline np.uint8_t kernel_tophat( if histo[i]: break - return < np.uint8_t > (i - g) + return (i - g) -cdef inline np.uint8_t kernel_noise_filter( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_noise_filter(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef Py_ssize_t min_i # early stop if at least one pixel of the neighborhood has the same g - if histo[g]>0: - return < np.uint8_t > 0 + if histo[g] > 0: + return 0 for i in range(g, -1, -1): if histo[i]: break - min_i = g-i + min_i = g - i for i in range(g, 256): if histo[i]: break - if i-g < min_i: - return < np.uint8_t > (i-g) + if i - g < min_i: + return (i - g) else: - return < np.uint8_t > min_i + return min_i -cdef inline np.uint8_t kernel_entropy( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): +cdef inline np.uint8_t kernel_entropy(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef Py_ssize_t i cdef float e,p e = 0. for i in range(256): - p = histo[i]/pop - if p>0: - e -= p*log2(p) + p = histo[i] / pop + if p > 0: + e -= p * log2(p) - return < np.uint8_t > e*10 + return e*10 -cdef inline np.uint8_t kernel_otsu( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): +cdef inline np.uint8_t kernel_otsu(Py_ssize_t * histo, float pop, np.uint8_t g, + float p0, float p1, Py_ssize_t s0, + Py_ssize_t s1): cdef Py_ssize_t i cdef Py_ssize_t max_i cdef float P, mu1, mu2, q1,new_q1, sigma_b, max_sigma_b cdef float mu = 0. # compute local mean - if pop: for i in range(256): mu += histo[i] * i mu = (mu / pop) else: - return < np.uint8_t > (0) + return (0) # maximizing the between class variance max_i = 0 @@ -289,21 +301,24 @@ cdef inline np.uint8_t kernel_otsu( max_sigma_b = 0. for i in range(1,256): - P = histo[i]/pop + P = histo[i] / pop new_q1 = q1 + P - if new_q1>0: - mu1 = (q1*mu1 + i*P)/new_q1 - mu2 = (mu-new_q1*mu1)/(1.-new_q1) - sigma_b = new_q1*(1.-new_q1)*(mu1-mu2)**2 - if sigma_b>max_sigma_b: + if new_q1 > 0: + mu1 = (q1 * mu1 + i * P) / new_q1 + mu2 = (mu - new_q1*mu1) / (1. - new_q1) + sigma_b = new_q1 * (1. - new_q1) * (mu1 - mu2)**2 + if sigma_b > max_sigma_b: max_sigma_b = sigma_b max_i = i q1 = new_q1 - if g>max_i: - return < np.uint8_t > 255 + if g > max_i: + return 255 else: - return < np.uint8_t > 0 + return 0 + + + # ----------------------------------------------------------------- # python wrappers # used only internally diff --git a/skimage/filter/rank/_crank8_percentiles.pyx b/skimage/filter/rank/_crank8_percentiles.pyx index 636295fd..777aec64 100644 --- a/skimage/filter/rank/_crank8_percentiles.pyx +++ b/skimage/filter/rank/_crank8_percentiles.pyx @@ -5,17 +5,17 @@ import numpy as np cimport numpy as np - -# import main loop from skimage.filter.rank._core8 cimport _core8, uint8_max, uint8_min + # ----------------------------------------------------------------- # kernels uint8 (SOFT version using percentiles) # ----------------------------------------------------------------- -cdef inline np.uint8_t kernel_autolevel( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_autolevel(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta if pop: @@ -37,16 +37,17 @@ cdef inline np.uint8_t kernel_autolevel( break delta = imax - imin if delta > 0: - return < np.uint8_t > (255 * (uint8_min(uint8_max(imin, g), imax) - imin) / delta) + return (255 \ + * (uint8_min(uint8_max(imin, g), imax) - imin) / delta) else: - return < np.uint8_t > (imax - imin) + return (imax - imin) else: - return < np.uint8_t > (128) + return (128) -cdef inline np.uint8_t kernel_gradient( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): +cdef inline np.uint8_t kernel_gradient(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta if pop: @@ -64,14 +65,14 @@ cdef inline np.uint8_t kernel_gradient( imax = i break - return < np.uint8_t > (imax - imin) + return (imax - imin) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_mean( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): +cdef inline np.uint8_t kernel_mean(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, mean, n if pop: @@ -84,15 +85,16 @@ cdef inline np.uint8_t kernel_mean( n += histo[i] mean += histo[i] * i if n > 0: - return < np.uint8_t > (1.0 * mean / n) + return (1.0 * mean / n) else: - return < np.uint8_t > (0) + return (0) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_mean_substraction( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_mean_substraction(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, mean, n if pop: @@ -105,15 +107,16 @@ cdef inline np.uint8_t kernel_mean_substraction( n += histo[i] mean += histo[i] * i if n > 0: - return < np.uint8_t > ((g - (mean / n)) * .5 + 127) + return ((g - (mean / n)) * .5 + 127) else: - return < np.uint8_t > (0) + return (0) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_morph_contr_enh( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, imin, imax, sum, delta if pop: @@ -131,19 +134,20 @@ cdef inline np.uint8_t kernel_morph_contr_enh( imax = i break if g > imax: - return < np.uint8_t > imax + return imax if g < imin: - return < np.uint8_t > imin + return imin if imax - g < g - imin: - return < np.uint8_t > imax + return imax else: - return < np.uint8_t > imin + return imin else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_percentile( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_percentile(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i cdef float sum = 0. @@ -153,13 +157,14 @@ cdef inline np.uint8_t kernel_percentile( if sum >= p0 * pop: break - return < np.uint8_t > (i) + return (i) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_pop( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, - Py_ssize_t s0, Py_ssize_t s1): + +cdef inline np.uint8_t kernel_pop(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i, sum, n if pop: @@ -169,13 +174,14 @@ cdef inline np.uint8_t kernel_pop( sum += histo[i] if (sum >= p0 * pop) and (sum <= p1 * pop): n += histo[i] - return < np.uint8_t > (n) + return (n) else: - return < np.uint8_t > (0) + return (0) -cdef inline np.uint8_t kernel_threshold( - Py_ssize_t * histo, float pop, np.uint8_t g, float p0, float p1, Py_ssize_t s0, - Py_ssize_t s1): + +cdef inline np.uint8_t kernel_threshold(Py_ssize_t * histo, float pop, + np.uint8_t g, float p0, float p1, + Py_ssize_t s0, Py_ssize_t s1): cdef int i cdef float sum = 0. @@ -185,9 +191,10 @@ cdef inline np.uint8_t kernel_threshold( if sum >= p0 * pop: break - return < np.uint8_t > (255 * (g >= i)) + return (255 * (g >= i)) else: - return < np.uint8_t > (0) + return (0) + # ----------------------------------------------------------------- # python wrappers