wassname/scikit-image
1
0
Fork 0
mirror of https://github.com/wassname/scikit-image.git synced 2026-09-11 12:43:04 +08:00
Code Issues Packages Projects Releases Wiki Activity

Improve code layout of kernel functions

Browse Source
This commit is contained in:
Johannes Schönberger
2012-11-10 08:24:44 +01:00
parent 4a14a217b9
commit 28e7b19c93
5 changed files with 378 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files
skimage/filter/rank/_crank16.pyx
+116 -89
View File
@@ -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 <np.uint16_t>(1. * (maxbin - 1) * (g - imin) / delta)
else:
return < np.uint16_t > (imax - imin)
return <np.uint16_t>(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 <np.uint16_t>(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 <np.uint16_t>(((maxbin - 1) * sum) / pop)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(imax - imin)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(i)
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(mean / pop)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>((g - mean / pop) / 2. + (midbin - 1))
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(i)
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(i)
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(imax)
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(imax)
else:
return < np.uint16_t > (imin)
return <np.uint16_t>(imin)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <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 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 <np.uint16_t>(g > (mean / pop))
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(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 <np.uint16_t>e*1000
# -----------------------------------------------------------------
skimage/filter/rank/_crank16_bilateral.pyx
+20 -14
View File
@@ -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 <np.uint16_t>(mean / bilat_pop)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(0)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(bilat_pop)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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)
skimage/filter/rank/_crank16_percentiles.pyx
+71 -48
View File
@@ -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 <np.uint16_t>(1.0 * (maxbin - 1) \
* (int_min(int_max(imin, g), imax) - imin) / delta)
else:
return < np.uint16_t > (imax - imin)
return <np.uint16_t>(imax - imin)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(imax - imin)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(1.0 * mean / n)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(0)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>((g - (mean / n)) * .5 + midbin)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(0)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>imax
if g < imin:
return < np.uint16_t > imin
return <np.uint16_t>imin
if imax - g < g - imin:
return < np.uint16_t > imax
return <np.uint16_t>imax
else:
return < np.uint16_t > imin
return <np.uint16_t>imin
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(i)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>(n)
else:
return < np.uint16_t > (0)
return <np.uint16_t>(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 <np.uint16_t>((maxbin - 1) * (g >= i))
else:
return < np.uint16_t > (0)
return <np.uint16_t>(0)
# -----------------------------------------------------------------
# python wrappers
skimage/filter/rank/_crank8.pyx
+116 -101
View File
@@ -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 <np.uint8_t>(255. * (g - imin) / delta)
else:
return < np.uint8_t > (imax - imin)
return <np.uint8_t>(imax - imin)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(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 <np.uint8_t>((255 * sum) / pop)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(imax - imin)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(i)
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(mean / pop)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>((g - mean / pop) / 2. + 127)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(i)
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(i)
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(imax)
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(imax)
else:
return < np.uint8_t > (imin)
return <np.uint8_t>(imin)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(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 <np.uint8_t>(g > (mean / pop))
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(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 <np.uint8_t>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 <np.uint8_t>(i - g)
else:
return < np.uint8_t > min_i
return <np.uint8_t>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 <np.uint8_t>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 <np.uint8_t>(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 <np.uint8_t>255
else:
return < np.uint8_t > 0
return <np.uint8_t>0
# -----------------------------------------------------------------
# python wrappers
# used only internally
skimage/filter/rank/_crank8_percentiles.pyx
+55 -48
View File
@@ -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 <np.uint8_t>(255 \
* (uint8_min(uint8_max(imin, g), imax) - imin) / delta)
else:
return < np.uint8_t > (imax - imin)
return <np.uint8_t>(imax - imin)
else:
return < np.uint8_t > (128)
return <np.uint8_t>(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 <np.uint8_t>(imax - imin)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(1.0 * mean / n)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(0)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>((g - (mean / n)) * .5 + 127)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(0)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>imax
if g < imin:
return < np.uint8_t > imin
return <np.uint8_t>imin
if imax - g < g - imin:
return < np.uint8_t > imax
return <np.uint8_t>imax
else:
return < np.uint8_t > imin
return <np.uint8_t>imin
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(i)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(n)
else:
return < np.uint8_t > (0)
return <np.uint8_t>(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 <np.uint8_t>(255 * (g >= i))
else:
return < np.uint8_t > (0)
return <np.uint8_t>(0)
# -----------------------------------------------------------------
# python wrappers