Filtering out border keypoints using masking

skimage/feature/_brief.py

@@ -142,7 +142,7 @@ def brief(image, keypoints, descriptor_size=256, mode='normal', patch_size=49,
 
     # Removing keypoints that are within (patch_size / 2) distance from the
     # image border
-    keypoints = _remove_border_keypoints(image, keypoints, patch_size // 2)
+    keypoints = keypoints[_remove_border_keypoints(image, keypoints, patch_size // 2)]
     keypoints = np.ascontiguousarray(keypoints)
 
     descriptors = np.zeros((keypoints.shape[0], descriptor_size), dtype=bool,

skimage/feature/censure.py

@@ -212,21 +212,16 @@ def censure_keypoints(image, n_scales=7, mode='DoB', non_max_threshold=0.15,
     if mode == 'DoB':
         return keypoints, scales
 
-    filtered_keypoints = np.empty((0, 2), dtype=np.int32)
-    filtered_scales = np.empty((0), dtype=np.int32)
+    cumulative_mask = np.zeros(keypoints.shape[0], dtype=np.bool)
 
     if mode == 'Octagon':
         for i in range(2, n_scales):
             c = (OCTAGON_OUTER_SHAPE[i - 1][0] - 1) // 2 + OCTAGON_OUTER_SHAPE[i - 1][1]
-            filtered_keypoints_for_scale = _remove_border_keypoints(image, keypoints[scales == i], c)
-            filtered_keypoints = np.vstack((filtered_keypoints, filtered_keypoints_for_scale))
-            filtered_scales = np.hstack((filtered_scales, np.asarray(len(filtered_keypoints_for_scale) * [i], dtype=np.int32)))
+            cumulative_mask = cumulative_mask | (_remove_border_keypoints(image, keypoints, c) & (scales == i))
 
     elif mode == 'STAR':
         for i in range(2, n_scales):
             c = STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]] + STAR_SHAPE[STAR_FILTER_SHAPE[i - 1][0]] // 2
-            filtered_keypoints_for_scale = _remove_border_keypoints(image, keypoints[scales == i], c)
-            filtered_keypoints = np.vstack((filtered_keypoints, filtered_keypoints_for_scale))
-            filtered_scales = np.hstack((filtered_scales, np.asarray(len(filtered_keypoints_for_scale) * [i], dtype=np.int32)))
+            cumulative_mask = cumulative_mask | (_remove_border_keypoints(image, keypoints, c) & (scales == i))
 
-    return filtered_keypoints, filtered_scales
+    return keypoints[cumulative_mask], scales[cumulative_mask]

skimage/feature/tests/test_censure.py

@@ -38,13 +38,13 @@ def test_censure_keypoints_moon_image_Octagon():
     the expected values for Octagon filter."""
     img = moon()
     actual_kp_Octagon, actual_scale = censure_keypoints(img, 7, 'Octagon', 0.15)
-    expected_kp_Octagon = np.array([[287, 250],
+    expected_kp_Octagon = np.array([[ 21, 496],
+                                    [ 35,  46],
+                                    [287, 250],
                                     [356, 239],
-                                    [463, 116],
-                                    [ 21, 496],
-                                    [ 35,  46]])
+                                    [463, 116]])
 
-    expected_scale = np.array([2, 2, 2, 3, 4], dtype=np.int32)
+    expected_scale = np.array([3, 4, 2, 2, 2], dtype=np.int32)
 
     assert_array_equal(expected_kp_Octagon, actual_kp_Octagon)
     assert_array_equal(expected_scale, actual_scale)
@@ -55,17 +55,18 @@ def test_censure_keypoints_moon_image_STAR():
     the expected values for STAR filter."""
     img = moon()
     actual_kp_STAR, actual_scale = censure_keypoints(img, 7, 'STAR', 0.15)
-    expected_kp_STAR = np.array([[185, 177],
-                                 [287, 250],
-                                 [463, 116],
-                                 [467, 260],
-                                 [ 21, 497],
+    expected_kp_STAR = np.array([[ 21, 497],
                                  [ 36,  46],
+                                 [117, 356],
+                                 [185, 177],
                                  [260, 227],
+                                 [287, 250],
                                  [357, 239],
                                  [451, 281],
-                                 [117, 356]])
-    expected_scale = np.array([2, 2, 2, 2, 3, 3, 3, 3, 5, 6], dtype=np.int32)
+                                 [463, 116],
+                                 [467, 260]])
+
+    expected_scale = np.array([3, 3, 6, 2, 3, 2, 3, 5, 2, 2], dtype=np.intp)
 
     assert_array_equal(expected_kp_STAR, actual_kp_STAR)
     assert_array_equal(expected_scale, actual_scale)

skimage/feature/util.py

@@ -5,10 +5,10 @@ def _remove_border_keypoints(image, keypoints, dist):
     width = image.shape[0]
     height = image.shape[1]
 
-    keypoints_filtering_mask = (dist - 1 < keypoints[:, 0]
-                                & keypoints[:, 0] < width - dist + 1
-                                & dist - 1 < keypoints[:, 1]
-                                & keypoints[:, 1] < height - dist + 1)
+    keypoints_filtering_mask = ((dist - 1 < keypoints[:, 0]) &
+                                (keypoints[:, 0] < width - dist + 1) &
+                                (dist - 1 < keypoints[:, 1]) &
+                                (keypoints[:, 1] < height - dist + 1))
 
     return keypoints_filtering_mask