From 7862b971be98c8408b121bb5b596360f0c71ceb7 Mon Sep 17 00:00:00 2001 From: Olivier Debeir Date: Mon, 15 Oct 2012 15:55:21 +0200 Subject: [PATCH] delete core8p --- skimage/rank/_core8p.pxd | 17 -- skimage/rank/_core8p.pyx | 266 --------------------------- skimage/rank/_crank8_percentiles.pyx | 34 ++-- skimage/rank/setup.py | 3 - skimage/rank/tests/demo_single.py | 6 +- 5 files changed, 20 insertions(+), 306 deletions(-) delete mode 100644 skimage/rank/_core8p.pxd delete mode 100644 skimage/rank/_core8p.pyx diff --git a/skimage/rank/_core8p.pxd b/skimage/rank/_core8p.pxd deleted file mode 100644 index 8d3181e8..00000000 --- a/skimage/rank/_core8p.pxd +++ /dev/null @@ -1,17 +0,0 @@ -cimport numpy as np - -# generic cdef functions -cdef inline np.uint8_t uint8_max(np.uint8_t a, np.uint8_t b) -cdef inline np.uint8_t uint8_min(np.uint8_t a, np.uint8_t b) - -#--------------------------------------------------------------------------- -# 8 bit core kernel receives extra information about data inferior and superior percentiles -#--------------------------------------------------------------------------- - -cdef inline _core8p(np.uint8_t kernel(int*, float, np.uint8_t, float, float), -np.ndarray[np.uint8_t, ndim=2] image, -np.ndarray[np.uint8_t, ndim=2] selem, -np.ndarray[np.uint8_t, ndim=2] mask, -np.ndarray[np.uint8_t, ndim=2] out, -char shift_x, char shift_y, float p0, float p1) - diff --git a/skimage/rank/_core8p.pyx b/skimage/rank/_core8p.pyx deleted file mode 100644 index b1adac70..00000000 --- a/skimage/rank/_core8p.pyx +++ /dev/null @@ -1,266 +0,0 @@ -#cython: cdivision=True -#cython: boundscheck=False -#cython: nonecheck=False -#cython: wraparound=False - -import numpy as np -cimport numpy as np -from libc.stdlib cimport malloc, free - -# generic cdef functions -cdef inline np.uint8_t uint8_max(np.uint8_t a, np.uint8_t b): return a if a >= b else b -cdef inline np.uint8_t uint8_min(np.uint8_t a, np.uint8_t b): return a if a <= b else b - -#--------------------------------------------------------------------------- -# 8 bit core kernel receives extra information about data inferior and superior percentiles -#--------------------------------------------------------------------------- - -cdef inline _core8p(np.uint8_t kernel(int*, float, np.uint8_t, float, float), -np.ndarray[np.uint8_t, ndim=2] image, -np.ndarray[np.uint8_t, ndim=2] selem, -np.ndarray[np.uint8_t, ndim=2] mask, -np.ndarray[np.uint8_t, ndim=2] out, -char shift_x, char shift_y, float p0, float p1): - """ Main loop, this function computes the histogram for each image point - - data is uint8 - - result is uint8 casted - """ - - cdef int rows = image.shape[0] - cdef int cols = image.shape[1] - cdef int srows = selem.shape[0] - cdef int scols = selem.shape[1] - - cdef int centre_r = int(selem.shape[0] / 2) + shift_y - cdef int centre_c = int(selem.shape[1] / 2) + shift_x - - # check that structuring element center is inside the element bounding box - assert centre_r >= 0 - assert centre_c >= 0 - assert centre_r < srows - assert centre_c < scols - - image = np.ascontiguousarray(image) - - if mask is None: - mask = np.ones((rows, cols), dtype=np.uint8) - else: - mask = np.ascontiguousarray(mask) - - if out is None: - out = np.zeros((rows, cols), dtype=np.uint8) - else: - out = np.ascontiguousarray(out) - - # create extended image and mask - cdef int erows = rows+srows-1 - cdef int ecols = cols+scols-1 - - cdef np.ndarray emask = np.zeros((erows, ecols), dtype=np.uint8) - cdef np.ndarray eimage = np.zeros((erows, ecols), dtype=np.uint8) - - eimage[centre_r:rows+centre_r,centre_c:cols+centre_c] = image - emask[centre_r:rows+centre_r,centre_c:cols+centre_c] = mask - - mask = np.ascontiguousarray(mask) - - # define pointers to the data - cdef np.uint8_t* eimage_data = eimage.data - cdef np.uint8_t* emask_data = emask.data - - cdef np.uint8_t* out_data = out.data - cdef np.uint8_t* image_data = image.data - cdef np.uint8_t* mask_data = mask.data - - # define local variable types - cdef int r, c, rr, cc, s, value, local_max, i, even_row - cdef float pop # number of pixels actually inside the neighborhood (float) - - # allocate memory with malloc - cdef int max_se = srows*scols - - # number of element in each attack border - cdef int num_se_n, num_se_s, num_se_e, num_se_w - - # the current local histogram distribution - cdef int* histo = malloc(256 * sizeof(int)) - - # these lists contain the relative pixel row and column for each of the 4 attack borders - # east, west, north and south - # e.g. se_e_r lists the rows of the east structuring element border - - cdef int* se_e_r = malloc(max_se * sizeof(int)) - cdef int* se_e_c = malloc(max_se * sizeof(int)) - cdef int* se_w_r = malloc(max_se * sizeof(int)) - cdef int* se_w_c = malloc(max_se * sizeof(int)) - cdef int* se_n_r = malloc(max_se * sizeof(int)) - cdef int* se_n_c = malloc(max_se * sizeof(int)) - cdef int* se_s_r = malloc(max_se * sizeof(int)) - cdef int* se_s_c = malloc(max_se * sizeof(int)) - - # build attack and release borders - # by using difference along axis - - t = np.hstack((selem,np.zeros((selem.shape[0],1)))) - t_e = np.diff(t,axis=1)==-1 - - t = np.hstack((np.zeros((selem.shape[0],1)),selem)) - t_w = np.diff(t,axis=1)==1 - - t = np.vstack((selem,np.zeros((1,selem.shape[1])))) - t_s = np.diff(t,axis=0)==-1 - - t = np.vstack((np.zeros((1,selem.shape[1])),selem)) - t_n = np.diff(t,axis=0)==1 - - num_se_n = num_se_s = num_se_e = num_se_w = 0 - - for r in range(srows): - for c in range(scols): - if t_e[r,c]: - se_e_r[num_se_e] = r - centre_r - se_e_c[num_se_e] = c - centre_c - num_se_e += 1 - if t_w[r,c]: - se_w_r[num_se_w] = r - centre_r - se_w_c[num_se_w] = c - centre_c - num_se_w += 1 - if t_n[r,c]: - se_n_r[num_se_n] = r - centre_r - se_n_c[num_se_n] = c - centre_c - num_se_n += 1 - if t_s[r,c]: - se_s_r[num_se_s] = r - centre_r - se_s_c[num_se_s] = c - centre_c - num_se_s += 1 - - # initial population and histogram - for i in range(256): - histo[i] = 0 - - pop = 0 - - for r in range(srows): - for c in range(scols): - rr = r - cc = c - if selem[r, c]: - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] += 1 - pop += 1. - - r = 0 - c = 0 - # kernel ------------------------------------------- - out_data[r * cols + c] = kernel(histo,pop,eimage_data[(r+centre_r) * ecols + c + centre_c],p0,p1) - # kernel ------------------------------------------- - - # main loop - r = 0 - for even_row in range(0,rows,2): - # ---> west to east - for c in range(1,cols): - for s in range(num_se_e): - rr = r + se_e_r[s] + centre_r - cc = c + se_e_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] += 1 - pop += 1. - for s in range(num_se_w): - rr = r + se_w_r[s] + centre_r - cc = c + se_w_c[s] + centre_c - 1 - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] -= 1 - pop -= 1. - - # kernel ------------------------------------------- - out_data[r * cols + c] = kernel(histo,pop,eimage_data[(r+centre_r) * ecols + c + centre_c],p0,p1) - # kernel ------------------------------------------- - - r += 1 # pass to the next row - if r>=rows: - break - - # ---> north to south - for s in range(num_se_s): - rr = r + se_s_r[s] + centre_r - cc = c + se_s_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] += 1 - pop += 1. - for s in range(num_se_n): - rr = r + se_n_r[s] + centre_r - 1 - cc = c + se_n_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] -= 1 - pop -= 1. - - # kernel ------------------------------------------- - out_data[r * cols + c] = kernel(histo,pop,eimage_data[(r+centre_r) * ecols + c + centre_c],p0,p1) - # kernel ------------------------------------------- - - # ---> east to west - for c in range(cols-2,-1,-1): - for s in range(num_se_w): - rr = r + se_w_r[s] + centre_r - cc = c + se_w_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] += 1 - pop += 1. - for s in range(num_se_e): - rr = r + se_e_r[s] + centre_r - cc = c + se_e_c[s] + centre_c + 1 - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] -= 1 - pop -= 1. - - # kernel ------------------------------------------- - out_data[r * cols + c] = kernel(histo,pop,eimage_data[(r+centre_r) * ecols + c + centre_c],p0,p1) - # kernel ------------------------------------------- - - r += 1 # pass to the next row - if r>=rows: - break - - # ---> north to south - for s in range(num_se_s): - rr = r + se_s_r[s] + centre_r - cc = c + se_s_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] += 1 - pop += 1. - for s in range(num_se_n): - rr = r + se_n_r[s] + centre_r - 1 - cc = c + se_n_c[s] + centre_c - if emask_data[rr * ecols + cc]: - value = eimage_data[rr * ecols + cc] - histo[value] -= 1 - pop -= 1. - - # kernel ------------------------------------------- - out_data[r * cols + c] = kernel(histo,pop,eimage_data[(r+centre_r) * ecols + c + centre_c],p0,p1) - # kernel ------------------------------------------- - - # release memory allocated by malloc - - free(se_e_r) - free(se_e_c) - free(se_w_r) - free(se_w_c) - free(se_n_r) - free(se_n_c) - free(se_s_r) - free(se_s_c) - - free(histo) - - return out - diff --git a/skimage/rank/_crank8_percentiles.pyx b/skimage/rank/_crank8_percentiles.pyx index 2299f04a..16ad49d5 100644 --- a/skimage/rank/_crank8_percentiles.pyx +++ b/skimage/rank/_crank8_percentiles.pyx @@ -7,13 +7,13 @@ import numpy as np cimport numpy as np # import main loop -from _core8p cimport _core8p,uint8_max,uint8_min +from _core8 cimport _core8,uint8_max,uint8_min # ----------------------------------------------------------------- # kernels uint8 (SOFT version using percentiles) # ----------------------------------------------------------------- -cdef inline np.uint8_t kernel_autolevel(int* histo, float pop, np.uint8_t g, float p0, float p1): +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: @@ -42,7 +42,7 @@ cdef inline np.uint8_t kernel_autolevel(int* histo, float pop, np.uint8_t g, flo return (128) -cdef inline np.uint8_t kernel_gradient(int* histo, float pop, np.uint8_t g, float p0, float p1): +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: @@ -65,7 +65,7 @@ cdef inline np.uint8_t kernel_gradient(int* histo, float pop, np.uint8_t g, floa return (0) -cdef inline np.uint8_t kernel_mean(int* histo, float pop, np.uint8_t g, float p0, float p1): +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,7 +84,7 @@ cdef inline np.uint8_t kernel_mean(int* histo, float pop, np.uint8_t g, float p0 else: return (0) -cdef inline np.uint8_t kernel_mean_substraction(int* histo, float pop, np.uint8_t g, float p0, float p1): +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: @@ -103,7 +103,7 @@ cdef inline np.uint8_t kernel_mean_substraction(int* histo, float pop, np.uint8_ else: return (0) -cdef inline np.uint8_t kernel_morph_contr_enh(int* histo, float pop, np.uint8_t g, float p0, float p1): +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,7 +131,7 @@ cdef inline np.uint8_t kernel_morph_contr_enh(int* histo, float pop, np.uint8_t else: return (0) -cdef inline np.uint8_t kernel_percentile(int* histo, float pop, np.uint8_t g, float p0, float p1): +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. @@ -145,7 +145,7 @@ cdef inline np.uint8_t kernel_percentile(int* histo, float pop, np.uint8_t g, fl else: return (0) -cdef inline np.uint8_t kernel_pop(int* histo, float pop, np.uint8_t g, float p0, float p1): +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: @@ -159,7 +159,7 @@ cdef inline np.uint8_t kernel_pop(int* histo, float pop, np.uint8_t g, float p0, else: return (0) -cdef inline np.uint8_t kernel_threshold(int* histo, float pop, np.uint8_t g, float p0, float p1): +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. @@ -183,7 +183,7 @@ def autolevel(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """autolevel """ - return _core8p(kernel_autolevel,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_autolevel,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def gradient(np.ndarray[np.uint8_t, ndim=2] image, @@ -193,7 +193,7 @@ def gradient(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return p0,p1 percentile gradient """ - return _core8p(kernel_gradient,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_gradient,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def mean(np.ndarray[np.uint8_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] selem, @@ -202,7 +202,7 @@ def mean(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return mean between [p0 and p1] percentiles """ - return _core8p(kernel_mean,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_mean,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def mean_substraction(np.ndarray[np.uint8_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] selem, @@ -211,7 +211,7 @@ def mean_substraction(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return original - mean between [p0 and p1] percentiles *.5 +127 """ - return _core8p(kernel_mean_substraction,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_mean_substraction,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def morph_contr_enh(np.ndarray[np.uint8_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] selem, @@ -220,7 +220,7 @@ def morph_contr_enh(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """reforce contrast using percentiles """ - return _core8p(kernel_morph_contr_enh,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_morph_contr_enh,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def percentile(np.ndarray[np.uint8_t, ndim=2] image, @@ -230,7 +230,7 @@ def percentile(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return p0 percentile """ - return _core8p(kernel_percentile,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_percentile,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def pop(np.ndarray[np.uint8_t, ndim=2] image, @@ -240,7 +240,7 @@ def pop(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return nb of pixels between [p0 and p1] """ - return _core8p(kernel_pop,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_pop,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) def threshold(np.ndarray[np.uint8_t, ndim=2] image, np.ndarray[np.uint8_t, ndim=2] selem, @@ -249,4 +249,4 @@ def threshold(np.ndarray[np.uint8_t, ndim=2] image, char shift_x=0, char shift_y=0, float p0=0., float p1=0.): """return 255 if g > percentile p0 """ - return _core8p(kernel_threshold,image,selem,mask,out,shift_x,shift_y,p0,p1) + return _core8(kernel_threshold,image,selem,mask,out,shift_x,shift_y,p0,p1,0,0) diff --git a/skimage/rank/setup.py b/skimage/rank/setup.py index 207ff18f..854748b8 100644 --- a/skimage/rank/setup.py +++ b/skimage/rank/setup.py @@ -13,7 +13,6 @@ def configuration(parent_package='', top_path=None): cython(['_core8.pyx'], working_path=base_path) - cython(['_core8p.pyx'], working_path=base_path) cython(['_core16.pyx'], working_path=base_path) cython(['_core16p.pyx'], working_path=base_path) cython(['_core16b.pyx'], working_path=base_path) @@ -25,8 +24,6 @@ def configuration(parent_package='', top_path=None): config.add_extension('_core8', sources=['_core8.c'], include_dirs=[get_numpy_include_dirs()]) - config.add_extension('_core8p', sources=['_core8p.c'], - include_dirs=[get_numpy_include_dirs()]) config.add_extension('_core16', sources=['_core16.c'], include_dirs=[get_numpy_include_dirs()]) config.add_extension('_core16p', sources=['_core16p.c'], diff --git a/skimage/rank/tests/demo_single.py b/skimage/rank/tests/demo_single.py index 5ec95d7b..7ff12b28 100644 --- a/skimage/rank/tests/demo_single.py +++ b/skimage/rank/tests/demo_single.py @@ -12,8 +12,8 @@ if __name__ == '__main__': a16 = data.camera().astype(np.uint16) selem = disk(10) - f8= rank.mean(a8,selem) - f16= rank.mean(a16,selem) + f8= rank.percentile_autolevel(a8,selem,p0=.0,p1=1.) + f16= rank.autolevel(a16,selem) print f8==f16 @@ -21,7 +21,7 @@ if __name__ == '__main__': plt.subplot(1,2,1) plt.imshow(f16) plt.subplot(1,2,2) - plt.imshow(f8-f16) + plt.imshow(f8) plt.show()