diff --git a/skimage/filter/rank/bilateral16_cy.pyx b/skimage/filter/rank/bilateral16_cy.pyx
index d9f68f73..63a89453 100644
--- a/skimage/filter/rank/bilateral16_cy.pyx
+++ b/skimage/filter/rank/bilateral16_cy.pyx
@@ -15,7 +15,7 @@ from .core16_cy cimport _core16
 ctypedef cnp.uint16_t dtype_t
 
 
-cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_mean(Py_ssize_t* histo, float pop,
                                 dtype_t g, Py_ssize_t bitdepth,
                                 Py_ssize_t maxbin, Py_ssize_t midbin,
                                 float p0, float p1,
@@ -37,7 +37,7 @@ cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_pop(Py_ssize_t* histo, float pop,
                                dtype_t g, Py_ssize_t bitdepth,
                                Py_ssize_t maxbin, Py_ssize_t midbin,
                                float p0, float p1,
diff --git a/skimage/filter/rank/core16_cy.pxd b/skimage/filter/rank/core16_cy.pxd
index f13f0fd1..cebf0aab 100644
--- a/skimage/filter/rank/core16_cy.pxd
+++ b/skimage/filter/rank/core16_cy.pxd
@@ -9,7 +9,7 @@ cdef dtype_t uint16_min(dtype_t a, dtype_t b)
 
 
 # 16-bit core kernel receives extra information about data bitdepth
-cdef void _core16(dtype_t kernel(Py_ssize_t *, float, dtype_t,
+cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
                                  Py_ssize_t, Py_ssize_t, Py_ssize_t, float,
                                  float, Py_ssize_t, Py_ssize_t),
                   dtype_t[:, ::1] image,
diff --git a/skimage/filter/rank/core16_cy.pyx b/skimage/filter/rank/core16_cy.pyx
index 25592d39..02acc93d 100644
--- a/skimage/filter/rank/core16_cy.pyx
+++ b/skimage/filter/rank/core16_cy.pyx
@@ -146,8 +146,8 @@ cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
     r = 0
     c = 0
     # kernel -------------------------------------------
-    out[r, c] = kernel(histo, pop, image[r, c],
-        bitdepth, maxbin, midbin, p0, p1, s0, s1)
+    out[r, c] = kernel(histo, pop, image[r, c], bitdepth, maxbin, midbin,
+                       p0, p1, s0, s1)
     # kernel -------------------------------------------
 
     # main loop
@@ -168,9 +168,8 @@ cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
                     histogram_decrement(histo, &pop, image[rr, cc])
 
             # kernel -------------------------------------------
-            out[r, c] = kernel(
-                histo, pop, image[r, c],
-                bitdepth, maxbin, midbin, p0, p1, s0, s1)
+            out[r, c] = kernel(histo, pop, image[r, c], bitdepth, maxbin,
+                               midbin, p0, p1, s0, s1)
             # kernel -------------------------------------------
 
         r += 1          # pass to the next row
@@ -192,7 +191,7 @@ cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
 
         # kernel -------------------------------------------
         out[r, c] = kernel(histo, pop, image[r, c],
-            bitdepth, maxbin, midbin, p0, p1, s0, s1)
+                           bitdepth, maxbin, midbin, p0, p1, s0, s1)
         # kernel -------------------------------------------
 
         # ---> east to west
@@ -210,9 +209,8 @@ cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
                     histogram_decrement(histo, &pop, image[rr, cc])
 
             # kernel -------------------------------------------
-            out[r, c] = kernel(
-                histo, pop, image[r, c],
-                bitdepth, maxbin, midbin, p0, p1, s0, s1)
+            out[r, c] = kernel(histo, pop, image[r, c], bitdepth, maxbin,
+                               midbin, p0, p1, s0, s1)
             # kernel -------------------------------------------
 
         r += 1           # pass to the next row
@@ -233,12 +231,11 @@ cdef void _core16(dtype_t kernel(Py_ssize_t*, float, dtype_t,
                 histogram_decrement(histo, &pop, image[rr, cc])
 
         # kernel -------------------------------------------
-        out[r, c] = kernel(histo, pop, image[r, c],
-            bitdepth, maxbin, midbin, p0, p1, s0, s1)
+        out[r, c] = kernel(histo, pop, image[r, c], bitdepth, maxbin, midbin,
+                           p0, p1, s0, s1)
         # kernel -------------------------------------------
 
     # release memory allocated by malloc
-
     free(se_e_r)
     free(se_e_c)
     free(se_w_r)
diff --git a/skimage/filter/rank/core8_cy.pxd b/skimage/filter/rank/core8_cy.pxd
index 8d7f9744..c2b709d4 100644
--- a/skimage/filter/rank/core8_cy.pxd
+++ b/skimage/filter/rank/core8_cy.pxd
@@ -15,7 +15,7 @@ cdef dtype_t is_in_mask(Py_ssize_t rows, Py_ssize_t cols,
 
 # 8-bit core kernel receives extra information about data inferior and superior
 # percentiles
-cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
+cdef void _core8(dtype_t kernel(Py_ssize_t*, float, dtype_t, float,
                                 float, Py_ssize_t, Py_ssize_t),
                  dtype_t[:, ::1] image,
                  char[:, ::1] selem,
diff --git a/skimage/filter/rank/core8_cy.pyx b/skimage/filter/rank/core8_cy.pyx
index b8d49a0f..357a1051 100644
--- a/skimage/filter/rank/core8_cy.pyx
+++ b/skimage/filter/rank/core8_cy.pyx
@@ -17,13 +17,13 @@ cdef inline dtype_t uint8_min(dtype_t a, dtype_t b):
     return a if a <= b else b
 
 
-cdef inline void histogram_increment(Py_ssize_t * histo, float * pop,
+cdef inline void histogram_increment(Py_ssize_t* histo, float* pop,
                                      dtype_t value):
     histo[value] += 1
     pop[0] += 1
 
 
-cdef inline void histogram_decrement(Py_ssize_t * histo, float * pop,
+cdef inline void histogram_decrement(Py_ssize_t* histo, float* pop,
                                      dtype_t value):
     histo[value] -= 1
     pop[0] -= 1
@@ -42,7 +42,7 @@ cdef inline dtype_t is_in_mask(Py_ssize_t rows, Py_ssize_t cols,
             return 0
 
 
-cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
+cdef void _core8(dtype_t kernel(Py_ssize_t*, float, dtype_t, float,
                                  float, Py_ssize_t, Py_ssize_t),
                  dtype_t[:, ::1] image,
                  char[:, ::1] selem,
@@ -83,19 +83,19 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
     cdef Py_ssize_t num_se_n, num_se_s, num_se_e, num_se_w
 
     # the current local histogram distribution
-    cdef Py_ssize_t * histo = <Py_ssize_t*>malloc(256 * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* histo = <Py_ssize_t*>malloc(256 * sizeof(Py_ssize_t))
 
     # 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 Py_ssize_t * se_e_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_e_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_w_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_w_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_n_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_n_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_s_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
-    cdef Py_ssize_t * se_s_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_e_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_e_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_w_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_w_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_n_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_n_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_s_r = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
+    cdef Py_ssize_t* se_s_c = <Py_ssize_t*>malloc(max_se * sizeof(Py_ssize_t))
 
     # build attack and release borders
     # by using difference along axis
@@ -149,10 +149,9 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
 
     r = 0
     c = 0
-    # kernel -------------------------------------------------------------------
-    out[r, c] = kernel(histo, pop, image[r, c],
-                                    p0, p1, s0, s1)
-    # kernel -------------------------------------------------------------------
+    # kernel ------------------------------------------------------------------
+    out[r, c] = kernel(histo, pop, image[r, c], p0, p1, s0, s1)
+    # kernel ------------------------------------------------------------------
 
     # main loop
     r = 0
@@ -171,10 +170,9 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
                 if is_in_mask(rows, cols, rr, cc, mask_data):
                     histogram_decrement(histo, &pop, image[rr, cc])
 
-            # kernel -----------------------------------------------------------
-            out[r, c] = \
-                kernel(histo, pop, image[r, c], p0, p1, s0, s1)
-            # kernel -----------------------------------------------------------
+            # kernel ----------------------------------------------------------
+            out[r, c] = kernel(histo, pop, image[r, c], p0, p1, s0, s1)
+            # kernel ----------------------------------------------------------
 
         r += 1          # pass to the next row
         if r >= rows:
@@ -193,10 +191,9 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
             if is_in_mask(rows, cols, rr, cc, mask_data):
                 histogram_decrement(histo, &pop, image[rr, cc])
 
-        # kernel ---------------------------------------------------------------
-        out[r, c] = kernel(histo, pop, image[r, c],
-                                        p0, p1, s0, s1)
-        # kernel ---------------------------------------------------------------
+        # kernel --------------------------------------------------------------
+        out[r, c] = kernel(histo, pop, image[r, c], p0, p1, s0, s1)
+        # kernel --------------------------------------------------------------
 
         # ---> east to west
         for c in range(cols - 2, -1, -1):
@@ -212,10 +209,10 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
                 if is_in_mask(rows, cols, rr, cc, mask_data):
                     histogram_decrement(histo, &pop, image[rr, cc])
 
-            # kernel -----------------------------------------------------------
+            # kernel ----------------------------------------------------------
             out[r, c] = kernel(
                 histo, pop, image[r, c], p0, p1, s0, s1)
-            # kernel -----------------------------------------------------------
+            # kernel ----------------------------------------------------------
 
         r += 1           # pass to the next row
         if r >= rows:
@@ -234,10 +231,9 @@ cdef void _core8(dtype_t kernel(Py_ssize_t *, float, dtype_t, float,
             if is_in_mask(rows, cols, rr, cc, mask_data):
                 histogram_decrement(histo, &pop, image[rr, cc])
 
-        # kernel ---------------------------------------------------------------
-        out[r, c] = kernel(histo, pop, image[r, c],
-                                        p0, p1, s0, s1)
-        # kernel ---------------------------------------------------------------
+        # kernel --------------------------------------------------------------
+        out[r, c] = kernel(histo, pop, image[r, c], p0, p1, s0, s1)
+        # kernel --------------------------------------------------------------
 
     # release memory allocated by malloc
     free(se_e_r)
diff --git a/skimage/filter/rank/generic16_cy.pyx b/skimage/filter/rank/generic16_cy.pyx
index 7b2a8088..32021e78 100644
--- a/skimage/filter/rank/generic16_cy.pyx
+++ b/skimage/filter/rank/generic16_cy.pyx
@@ -12,7 +12,7 @@ from .core16_cy cimport dtype_t, _core16
 # kernels uint16 take extra parameter for defining the bitdepth
 # -----------------------------------------------------------------
 
-cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_autolevel(Py_ssize_t* histo, float pop,
                                      dtype_t g, Py_ssize_t bitdepth,
                                      Py_ssize_t maxbin, Py_ssize_t midbin,
                                      float p0, float p1,
@@ -35,7 +35,7 @@ cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
         return <dtype_t>(imax - imin)
 
 
-cdef inline dtype_t kernel_bottomhat(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_bottomhat(Py_ssize_t* histo, float pop,
                                      dtype_t g, Py_ssize_t bitdepth,
                                      Py_ssize_t maxbin, Py_ssize_t midbin,
                                      float p0, float p1,
@@ -51,7 +51,7 @@ cdef inline dtype_t kernel_bottomhat(Py_ssize_t * histo, float pop,
     else:
         return <dtype_t>(0)
 
-cdef inline dtype_t kernel_equalize(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_equalize(Py_ssize_t* histo, float pop,
                                     dtype_t g, Py_ssize_t bitdepth,
                                     Py_ssize_t maxbin, Py_ssize_t midbin,
                                     float p0, float p1,
@@ -70,7 +70,7 @@ cdef inline dtype_t kernel_equalize(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_gradient(Py_ssize_t* histo, float pop,
                                     dtype_t g, Py_ssize_t bitdepth,
                                     Py_ssize_t maxbin, Py_ssize_t midbin,
                                     float p0, float p1,
@@ -91,7 +91,7 @@ cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_maximum(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_maximum(Py_ssize_t* histo, float pop,
                                    dtype_t g, Py_ssize_t bitdepth,
                                    Py_ssize_t maxbin, Py_ssize_t midbin,
                                    float p0, float p1,
@@ -106,7 +106,7 @@ cdef inline dtype_t kernel_maximum(Py_ssize_t * histo, float pop,
     return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_mean(Py_ssize_t* histo, float pop,
                                 dtype_t g, Py_ssize_t bitdepth,
                                 Py_ssize_t maxbin, Py_ssize_t midbin,
                                 float p0, float p1,
@@ -122,7 +122,7 @@ cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_meansubtraction(Py_ssize_t * histo,
+cdef inline dtype_t kernel_meansubtraction(Py_ssize_t* histo,
                                             float pop,
                                             dtype_t g,
                                             Py_ssize_t bitdepth,
@@ -141,7 +141,7 @@ cdef inline dtype_t kernel_meansubtraction(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_median(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_median(Py_ssize_t* histo, float pop,
                                   dtype_t g, Py_ssize_t bitdepth,
                                   Py_ssize_t maxbin, Py_ssize_t midbin,
                                   float p0, float p1,
@@ -159,7 +159,7 @@ cdef inline dtype_t kernel_median(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_minimum(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_minimum(Py_ssize_t* histo, float pop,
                                    dtype_t g, Py_ssize_t bitdepth,
                                    Py_ssize_t maxbin, Py_ssize_t midbin,
                                    float p0, float p1,
@@ -174,7 +174,7 @@ cdef inline dtype_t kernel_minimum(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_modal(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_modal(Py_ssize_t* histo, float pop,
                                  dtype_t g, Py_ssize_t bitdepth,
                                  Py_ssize_t maxbin, Py_ssize_t midbin,
                                  float p0, float p1,
@@ -191,7 +191,7 @@ cdef inline dtype_t kernel_modal(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
+cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t* histo,
                                            float pop,
                                            dtype_t g,
                                            Py_ssize_t bitdepth,
@@ -218,7 +218,7 @@ cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_pop(Py_ssize_t* histo, float pop,
                                dtype_t g, Py_ssize_t bitdepth,
                                Py_ssize_t maxbin, Py_ssize_t midbin,
                                float p0, float p1,
@@ -226,7 +226,7 @@ cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
     return <dtype_t>(pop)
 
 
-cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_threshold(Py_ssize_t* histo, float pop,
                                      dtype_t g, Py_ssize_t bitdepth,
                                      Py_ssize_t maxbin, Py_ssize_t midbin,
                                      float p0, float p1,
@@ -242,7 +242,7 @@ cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_tophat(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_tophat(Py_ssize_t* histo, float pop,
                                   dtype_t g, Py_ssize_t bitdepth,
                                   Py_ssize_t maxbin, Py_ssize_t midbin,
                                   float p0, float p1,
@@ -258,7 +258,7 @@ cdef inline dtype_t kernel_tophat(Py_ssize_t * histo, float pop,
     else:
         return <dtype_t>(0)
 
-cdef inline dtype_t kernel_entropy(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_entropy(Py_ssize_t* histo, float pop,
                                    dtype_t g, Py_ssize_t bitdepth,
                                    Py_ssize_t maxbin, Py_ssize_t midbin,
                                    float p0, float p1,
diff --git a/skimage/filter/rank/generic8_cy.pyx b/skimage/filter/rank/generic8_cy.pyx
index 62749041..93473a85 100644
--- a/skimage/filter/rank/generic8_cy.pyx
+++ b/skimage/filter/rank/generic8_cy.pyx
@@ -13,7 +13,7 @@ from .core8_cy cimport dtype_t, _core8
 # -----------------------------------------------------------------
 
 
-cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_autolevel(Py_ssize_t* histo, float pop,
                                      dtype_t g, float p0, float p1,
                                      Py_ssize_t s0, Py_ssize_t s1):
 
@@ -37,7 +37,7 @@ cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_bottomhat(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_bottomhat(Py_ssize_t* histo, float pop,
                                      dtype_t g, float p0, float p1,
                                      Py_ssize_t s0, Py_ssize_t s1):
 
@@ -53,7 +53,7 @@ cdef inline dtype_t kernel_bottomhat(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_equalize(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_equalize(Py_ssize_t* histo, float pop,
                                     dtype_t g, float p0, float p1,
                                     Py_ssize_t s0, Py_ssize_t s1):
 
@@ -71,7 +71,7 @@ cdef inline dtype_t kernel_equalize(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_gradient(Py_ssize_t* histo, float pop,
                                     dtype_t g, float p0, float p1,
                                     Py_ssize_t s0, Py_ssize_t s1):
 
@@ -91,7 +91,7 @@ cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_maximum(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_maximum(Py_ssize_t* histo, float pop,
                                    dtype_t g, float p0, float p1,
                                    Py_ssize_t s0, Py_ssize_t s1):
 
@@ -105,7 +105,7 @@ cdef inline dtype_t kernel_maximum(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_mean(Py_ssize_t* histo, float pop,
                                 dtype_t g, float p0, float p1,
                                 Py_ssize_t s0, Py_ssize_t s1):
 
@@ -120,7 +120,7 @@ cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_meansubtraction(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_meansubtraction(Py_ssize_t* histo, float pop,
                                             dtype_t g, float p0, float p1,
                                             Py_ssize_t s0, Py_ssize_t s1):
 
@@ -135,7 +135,7 @@ cdef inline dtype_t kernel_meansubtraction(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_median(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_median(Py_ssize_t* histo, float pop,
                                   dtype_t g, float p0, float p1,
                                   Py_ssize_t s0, Py_ssize_t s1):
 
@@ -152,7 +152,7 @@ cdef inline dtype_t kernel_median(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_minimum(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_minimum(Py_ssize_t* histo, float pop,
                                    dtype_t g, float p0, float p1,
                                    Py_ssize_t s0, Py_ssize_t s1):
 
@@ -166,7 +166,7 @@ cdef inline dtype_t kernel_minimum(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_modal(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_modal(Py_ssize_t* histo, float pop,
                                  dtype_t g, float p0, float p1,
                                  Py_ssize_t s0, Py_ssize_t s1):
 
@@ -182,7 +182,7 @@ cdef inline dtype_t kernel_modal(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t* histo, float pop,
                                            dtype_t g, float p0, float p1,
                                            Py_ssize_t s0, Py_ssize_t s1):
 
@@ -205,14 +205,14 @@ cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_pop(Py_ssize_t* histo, float pop,
                                dtype_t g, float p0, float p1,
                                Py_ssize_t s0, Py_ssize_t s1):
 
     return <dtype_t>(pop)
 
 
-cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_threshold(Py_ssize_t* histo, float pop,
                                      dtype_t g, float p0, float p1,
                                      Py_ssize_t s0, Py_ssize_t s1):
 
@@ -227,7 +227,7 @@ cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_tophat(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_tophat(Py_ssize_t* histo, float pop,
                                   dtype_t g, float p0, float p1,
                                   Py_ssize_t s0, Py_ssize_t s1):
 
@@ -242,7 +242,7 @@ cdef inline dtype_t kernel_tophat(Py_ssize_t * histo, float pop,
     else:
         return <dtype_t>(0)
 
-cdef inline dtype_t kernel_noise_filter(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_noise_filter(Py_ssize_t* histo, float pop,
                                         dtype_t g, float p0, float p1,
                                         Py_ssize_t s0, Py_ssize_t s1):
 
@@ -266,7 +266,7 @@ cdef inline dtype_t kernel_noise_filter(Py_ssize_t * histo, float pop,
         return <dtype_t>min_i
 
 
-cdef inline dtype_t kernel_entropy(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_entropy(Py_ssize_t* histo, float pop,
                                    dtype_t g, float p0, float p1,
                                    Py_ssize_t s0, Py_ssize_t s1):
     cdef Py_ssize_t i
@@ -284,7 +284,7 @@ cdef inline dtype_t kernel_entropy(Py_ssize_t * histo, float pop,
     else:
         return <dtype_t>(0)
 
-cdef inline dtype_t kernel_otsu(Py_ssize_t * histo, float pop, dtype_t g,
+cdef inline dtype_t kernel_otsu(Py_ssize_t* histo, float pop, dtype_t g,
                                 float p0, float p1, Py_ssize_t s0,
                                 Py_ssize_t s1):
     cdef Py_ssize_t i
diff --git a/skimage/filter/rank/percentile16_cy.pyx b/skimage/filter/rank/percentile16_cy.pyx
index 8680aae4..d99dc3c8 100644
--- a/skimage/filter/rank/percentile16_cy.pyx
+++ b/skimage/filter/rank/percentile16_cy.pyx
@@ -11,7 +11,7 @@ from .core16_cy cimport dtype_t, _core16, uint16_min, uint16_max
 # kernels uint16 (SOFT version using percentiles)
 # -----------------------------------------------------------------
 
-cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_autolevel(Py_ssize_t* histo, float pop,
                                      dtype_t g, Py_ssize_t bitdepth,
                                      Py_ssize_t maxbin, Py_ssize_t midbin,
                                      float p0, float p1,
@@ -45,7 +45,7 @@ cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_gradient(Py_ssize_t* histo, float pop,
                                     dtype_t g, Py_ssize_t bitdepth,
                                     Py_ssize_t maxbin, Py_ssize_t midbin,
                                     float p0, float p1,
@@ -73,7 +73,7 @@ cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_mean(Py_ssize_t* histo, float pop,
                                 dtype_t g, Py_ssize_t bitdepth,
                                 Py_ssize_t maxbin, Py_ssize_t midbin,
                                 float p0, float p1,
@@ -99,7 +99,7 @@ cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t * histo,
+cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t* histo,
                                              float pop,
                                              dtype_t g,
                                              Py_ssize_t bitdepth,
@@ -127,7 +127,7 @@ cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
+cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t* histo,
                                            float pop,
                                            dtype_t g,
                                            Py_ssize_t bitdepth,
@@ -164,7 +164,7 @@ cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_percentile(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_percentile(Py_ssize_t* histo, float pop,
                                       dtype_t g, Py_ssize_t bitdepth,
                                       Py_ssize_t maxbin, Py_ssize_t midbin,
                                       float p0, float p1,
@@ -184,7 +184,7 @@ cdef inline dtype_t kernel_percentile(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_pop(Py_ssize_t* histo, float pop,
                                dtype_t g, Py_ssize_t bitdepth,
                                Py_ssize_t maxbin, Py_ssize_t midbin,
                                float p0, float p1,
@@ -204,7 +204,7 @@ cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_threshold(Py_ssize_t* histo, float pop,
                                      dtype_t g, Py_ssize_t bitdepth,
                                      Py_ssize_t maxbin, Py_ssize_t midbin,
                                      float p0, float p1,
diff --git a/skimage/filter/rank/percentile8_cy.pyx b/skimage/filter/rank/percentile8_cy.pyx
index 6c37cf66..3ce63478 100644
--- a/skimage/filter/rank/percentile8_cy.pyx
+++ b/skimage/filter/rank/percentile8_cy.pyx
@@ -12,7 +12,7 @@ from .core8_cy cimport dtype_t, _core8, uint8_max, uint8_min
 # -----------------------------------------------------------------
 
 
-cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_autolevel(Py_ssize_t* histo, float pop,
                                      dtype_t g, float p0, float p1,
                                      Py_ssize_t s0, Py_ssize_t s1):
     cdef int i, imin, imax, sum, delta
@@ -44,7 +44,7 @@ cdef inline dtype_t kernel_autolevel(Py_ssize_t * histo, float pop,
         return <dtype_t>(128)
 
 
-cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_gradient(Py_ssize_t* histo, float pop,
                                     dtype_t g, float p0, float p1,
                                     Py_ssize_t s0, Py_ssize_t s1):
     cdef int i, imin, imax, sum, delta
@@ -69,7 +69,7 @@ cdef inline dtype_t kernel_gradient(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_mean(Py_ssize_t* histo, float pop,
                                 dtype_t g, float p0, float p1,
                                 Py_ssize_t s0, Py_ssize_t s1):
     cdef int i, sum, mean, n
@@ -91,7 +91,7 @@ cdef inline dtype_t kernel_mean(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t * histo,
+cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t* histo,
                                              float pop,
                                              dtype_t g,
                                              float p0, float p1,
@@ -115,7 +115,7 @@ cdef inline dtype_t kernel_mean_subtraction(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
+cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t* histo,
                                            float pop,
                                            dtype_t g, float p0, float p1,
                                            Py_ssize_t s0, Py_ssize_t s1):
@@ -147,7 +147,7 @@ cdef inline dtype_t kernel_morph_contr_enh(Py_ssize_t * histo,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_percentile(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_percentile(Py_ssize_t* histo, float pop,
                                       dtype_t g, float p0, float p1,
                                       Py_ssize_t s0, Py_ssize_t s1):
     cdef int i
@@ -164,7 +164,7 @@ cdef inline dtype_t kernel_percentile(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_pop(Py_ssize_t* histo, float pop,
                                dtype_t g, float p0, float p1,
                                Py_ssize_t s0, Py_ssize_t s1):
     cdef int i, sum, n
@@ -181,7 +181,7 @@ cdef inline dtype_t kernel_pop(Py_ssize_t * histo, float pop,
         return <dtype_t>(0)
 
 
-cdef inline dtype_t kernel_threshold(Py_ssize_t * histo, float pop,
+cdef inline dtype_t kernel_threshold(Py_ssize_t* histo, float pop,
                                      dtype_t g, float p0, float p1,
                                      Py_ssize_t s0, Py_ssize_t s1):
     cdef int i