add rank filter sum

skimage/filter/rank/__init__.py

@@ -1,6 +1,6 @@
 from .generic import (autolevel, bottomhat, equalize, gradient, maximum, mean,
                       subtract_mean, median, minimum, modal, enhance_contrast,
-                      pop, threshold, tophat, noise_filter, entropy, otsu)
+                      pop, threshold, tophat, noise_filter, entropy, otsu, sum)
 from ._percentile import (autolevel_percentile, gradient_percentile,
                           mean_percentile, subtract_mean_percentile,
                           enhance_contrast_percentile, percentile,
@@ -51,6 +51,7 @@ __all__ = ['autolevel',
            'pop',
            'pop_percentile',
            'pop_bilateral',
+           'sum',
            'threshold',
            'threshold_percentile',
            'tophat',

skimage/filter/rank/generic.py

@@ -528,6 +528,52 @@ def pop(image, selem, out=None, mask=None, shift_x=False, shift_y=False):
     return _apply(generic_cy._pop, image, selem, out=out,
                   mask=mask, shift_x=shift_x, shift_y=shift_y)
 
+def sum(image, selem, out=None, mask=None, shift_x=False, shift_y=False):
+    """Return the sum of pixels inside the neighborhood. If sum does not fit the data type,folding is possible.
+
+    Parameters
+    ----------
+    image : ndarray (uint8, uint16)
+        Image array.
+    selem : ndarray
+        The neighborhood expressed as a 2-D array of 1's and 0's.
+    out : ndarray (same dtype as input)
+        If None, a new array will be allocated.
+    mask : ndarray
+        Mask array that defines (>0) area of the image included in the local
+        neighborhood. If None, the complete image is used (default).
+    shift_x, shift_y : int
+        Offset added to the structuring element center point. Shift is bounded
+        to the structuring element sizes (center must be inside the given
+        structuring element).
+
+    Returns
+    -------
+    out : ndarray (same dtype as input image)
+        Output image.
+
+    Examples
+    --------
+    >>> # Local mean
+    >>> from skimage.morphology import square
+    >>> import skimage.filter.rank as rank
+    >>> ima = 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(ima, 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)
+
+    """
+
+    return _apply(generic_cy._sum, image, selem, out=out,
+                  mask=mask, shift_x=shift_x, shift_y=shift_y)
+
 
 def threshold(image, selem, out=None, mask=None, shift_x=False, shift_y=False):
     """Return greyscale local threshold of an image.

skimage/filter/rank/generic_cy.pyx

@@ -221,6 +221,21 @@ cdef inline double _kernel_pop(Py_ssize_t* histo, double pop, dtype_t g,
 
     return pop
 
+cdef inline double _kernel_sum(Py_ssize_t* histo, double pop,dtype_t g,
+                                Py_ssize_t max_bin, Py_ssize_t mid_bin,
+                                double p0, double p1,
+                                Py_ssize_t s0, Py_ssize_t s1):
+
+    cdef Py_ssize_t i
+    cdef Py_ssize_t sum = 0
+
+    if pop:
+        for i in range(max_bin):
+            sum += histo[i] * i
+        return sum
+    else:
+        return 0
+
 
 cdef inline double _kernel_threshold(Py_ssize_t* histo, double pop, dtype_t g,
                                      Py_ssize_t max_bin, Py_ssize_t mid_bin,
@@ -455,6 +470,15 @@ def _pop(dtype_t[:, ::1] image,
     _core(_kernel_pop[dtype_t], image, selem, mask, out,
           shift_x, shift_y, 0, 0, 0, 0, max_bin)
 
+def _sum(dtype_t[:, ::1] image,
+                   char[:, ::1] selem,
+                   char[:, ::1] mask,
+                   dtype_t_out[:, ::1] out,
+                   char shift_x, char shift_y, Py_ssize_t max_bin):
+
+    _core(_kernel_sum[dtype_t], image, selem, mask,
+          out, shift_x, shift_y, 0, 0, 0, 0, max_bin)
+
 
 def _threshold(dtype_t[:, ::1] image,
                char[:, ::1] selem,

skimage/filter/rank/tests/test_rank.py

@@ -498,6 +498,41 @@ def test_percentile_median():
     img_max = rank.median(img16, selem=selem)
     assert_array_equal(img_p0, img_max)
 
+def test_sum():
+    # check the number of valid pixels in the neighborhood
+
+    image8 = 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)
+    image16 = 400*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)
+    elem = np.ones((3, 3), dtype=np.uint8)
+    out8 = np.empty_like(image8)
+    out16 = np.empty_like(image16)
+    mask = np.ones(image8.shape, dtype=np.uint8)
+
+    rank.sum(image=image8, selem=elem, out=out8, mask=mask)
+    r =  np.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=np.uint8)
+    assert_array_equal(r, out8)
+
+    rank.sum(image=image16, selem=elem, out=out16, mask=mask)
+    r = 400* np.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=np.uint16)
+    print image16
+    assert_array_equal(r, out16)
+
 
 if __name__ == "__main__":
     run_module_suite()