scikit-image

1
import numpy as np
2
import pytest
3
from numpy.testing import assert_almost_equal, assert_equal
4

5
from skimage import data
6
from skimage._shared.testing import run_in_parallel
7
from skimage.feature import SIFT
8
from skimage.util.dtype import _convert
9

10
img = data.coins()
11

12

13
@run_in_parallel()
14
@pytest.mark.parametrize('dtype', ['float32', 'float64', 'uint8', 'uint16', 'int64'])
15
def test_keypoints_sift(dtype):
16
    _img = _convert(img, dtype)
17
    detector_extractor = SIFT()
18
    detector_extractor.detect_and_extract(_img)
19

20
    exp_keypoint_rows = np.array([18, 18, 19, 22, 26, 26, 30, 31, 31, 32])
21
    exp_keypoint_cols = np.array([331, 331, 325, 330, 310, 330, 205, 323, 149, 338])
22

23
    exp_octaves = np.array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
24

25
    exp_position_rows = np.array(
26
        [
27
            17.81909936,
28
            17.81909936,
29
            19.05454661,
30
            21.85933727,
31
            25.54800708,
32
            26.25710504,
33
            29.90826307,
34
            30.78713806,
35
            30.87953572,
36
            31.72557969,
37
        ]
38
    )
39

40
    exp_position_cols = np.array(
41
        [
42
            331.49693187,
43
            331.49693187,
44
            325.24476016,
45
            330.44616424,
46
            310.33932904,
47
            330.46155224,
48
            204.74535177,
49
            322.84100812,
50
            149.43192282,
51
            337.89643013,
52
        ]
53
    )
54

55
    exp_orientations = np.array(
56
        [
57
            0.26391655,
58
            0.26391655,
59
            0.39134262,
60
            1.77063053,
61
            0.98637565,
62
            1.37997279,
63
            0.4919992,
64
            1.48615988,
65
            0.33753212,
66
            1.64859617,
67
        ]
68
    )
69

70
    exp_scales = np.array([2, 2, 1, 3, 3, 1, 2, 1, 1, 1])
71

72
    exp_sigmas = np.array(
73
        [
74
            1.35160379,
75
            1.35160379,
76
            0.94551567,
77
            1.52377498,
78
            1.55173233,
79
            0.93973722,
80
            1.37594124,
81
            1.06663786,
82
            1.04827034,
83
            1.0378916,
84
        ]
85
    )
86

87
    exp_scalespace_sigmas = np.array(
88
        [
89
            [0.8, 1.00793684, 1.26992084, 1.6, 2.01587368, 2.53984168],
90
            [1.6, 2.01587368, 2.53984168, 3.2, 4.03174736, 5.07968337],
91
            [3.2, 4.03174736, 5.07968337, 6.4, 8.06349472, 10.15936673],
92
            [6.4, 8.06349472, 10.15936673, 12.8, 16.12698944, 20.31873347],
93
            [12.8, 16.12698944, 20.31873347, 25.6, 32.25397888, 40.63746693],
94
            [25.6, 32.25397888, 40.63746693, 51.2, 64.50795775, 81.27493386],
95
        ]
96
    )
97

98
    assert_almost_equal(exp_keypoint_rows, detector_extractor.keypoints[:10, 0])
99
    assert_almost_equal(exp_keypoint_cols, detector_extractor.keypoints[:10, 1])
100
    assert_almost_equal(exp_octaves, detector_extractor.octaves[:10])
101
    assert_almost_equal(
102
        exp_position_rows, detector_extractor.positions[:10, 0], decimal=4
103
    )
104
    assert_almost_equal(
105
        exp_position_cols, detector_extractor.positions[:10, 1], decimal=4
106
    )
107
    assert_almost_equal(
108
        exp_orientations, detector_extractor.orientations[:10], decimal=4
109
    )
110
    assert_almost_equal(exp_scales, detector_extractor.scales[:10])
111
    assert_almost_equal(exp_sigmas, detector_extractor.sigmas[:10], decimal=4)
112
    assert_almost_equal(
113
        exp_scalespace_sigmas, detector_extractor.scalespace_sigmas, decimal=4
114
    )
115

116
    detector_extractor2 = SIFT()
117
    detector_extractor2.detect(img)
118
    detector_extractor2.extract(img)
119
    assert_almost_equal(
120
        detector_extractor.keypoints[:10, 0], detector_extractor2.keypoints[:10, 0]
121
    )
122
    assert_almost_equal(
123
        detector_extractor.keypoints[:10, 0], detector_extractor2.keypoints[:10, 0]
124
    )
125

126

127
def test_descriptor_sift():
128
    detector_extractor = SIFT(n_hist=2, n_ori=4)
129
    exp_descriptors = np.array(
130
        [
131
            [173, 30, 55, 32, 173, 16, 45, 82, 173, 154, 170, 173, 173, 169, 65, 110],
132
            [173, 30, 55, 32, 173, 16, 45, 82, 173, 154, 170, 173, 173, 169, 65, 110],
133
            [189, 52, 18, 18, 189, 11, 21, 55, 189, 75, 173, 91, 189, 65, 189, 162],
134
            [172, 156, 185, 66, 92, 76, 78, 185, 185, 87, 88, 82, 98, 56, 96, 185],
135
            [216, 19, 40, 9, 196, 7, 57, 36, 216, 56, 158, 29, 216, 42, 144, 154],
136
            [169, 120, 169, 91, 129, 108, 169, 67, 169, 142, 111, 95, 169, 120, 69, 41],
137
            [199, 10, 138, 44, 178, 11, 161, 34, 199, 113, 73, 64, 199, 82, 31, 178],
138
            [154, 56, 154, 49, 144, 154, 154, 78, 154, 51, 154, 83, 154, 154, 154, 72],
139
            [230, 46, 47, 21, 230, 15, 65, 95, 230, 52, 72, 51, 230, 19, 59, 130],
140
            [
141
                155,
142
                117,
143
                154,
144
                102,
145
                155,
146
                155,
147
                90,
148
                110,
149
                145,
150
                127,
151
                155,
152
                50,
153
                57,
154
                155,
155
                155,
156
                70,
157
            ],
158
        ],
159
        dtype=np.uint8,
160
    )
161

162
    detector_extractor.detect_and_extract(img)
163

164
    assert_equal(exp_descriptors, detector_extractor.descriptors[:10])
165

166
    keypoints_count = detector_extractor.keypoints.shape[0]
167
    assert keypoints_count == detector_extractor.descriptors.shape[0]
168
    assert keypoints_count == detector_extractor.orientations.shape[0]
169
    assert keypoints_count == detector_extractor.octaves.shape[0]
170
    assert keypoints_count == detector_extractor.positions.shape[0]
171
    assert keypoints_count == detector_extractor.scales.shape[0]
172
    assert keypoints_count == detector_extractor.scales.shape[0]
173

174

175
def test_no_descriptors_extracted_sift():
176
    img = np.ones((128, 128))
177
    detector_extractor = SIFT()
178
    with pytest.raises(RuntimeError):
179
        detector_extractor.detect_and_extract(img)
180