Commit 529d39c8 authored by Jay's avatar Jay
Browse files

Matcher updated to NX2

parent e5bbe99c
Loading
Loading
Loading
Loading
+139 −129
Changes for autocnet/matcher/tests/test_ciratefi.py: 139 added lines, 129 removed lines.
Original line number Diff line number Diff line
@@ -11,154 +11,164 @@ from autocnet.examples import get_path
from autocnet.matcher import subpixel as sp
from .. import ciratefi

import pytest

# Can be parameterized for more exhaustive tests
upsampling = 10
alpha = math.pi/2
cifi_thresh = 90
rafi_thresh = 90
tefi_thresh = 100
use_percentile = True
radii = list(range(1, 3))

@pytest.fixture
def img():
    return imread(get_path('AS15-M-0298_SML.png'), flatten=True)

@pytest.fixture
def img_coord():
    return (482.09783936, 652.40679932)

@pytest.fixture
def template(img, img_coord):
    template = sp.clip_roi(img, img_coord, 5)
    template = rotate(template, 90)
    template = imresize(template, 1.)
    return template

@pytest.fixture
def search(img, img_coord):
    search = sp.clip_roi(img, img_coord, 21)
    search = rotate(search, 0)
    search = imresize(search, 1.)
    return search

@pytest.fixture
def offset_template(img, img_coord):
    offset = (1, 1)

    offset_template = sp.clip_roi(img, np.add(img_coord, offset), 5)
    offset_template = rotate(offset_template, 0)
    offset_template = imresize(offset_template, 1.)

    return offset_template

def test_cifi_radii_too_large(template, search):
    # check all warnings
    with pytest.warns(UserWarning):
        ciratefi.cifi(template, search, 1.0, radii=[100], use_percentile=False)

class TestCiratefi(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        img = imread(get_path('AS15-M-0298_SML.png'), flatten=True)
        img_coord = (482.09783936, 652.40679932)

        cls.template = sp.clip_roi(img, img_coord, 5)
        cls.template = rotate(cls.template, 90)
        cls.template = imresize(cls.template, 1.)
def test_cifi_bounds_error(template, search):
    with pytest.raises(ValueError):
        ciratefi.cifi(template, search, -1.1, use_percentile=False)

        cls.search = sp.clip_roi(img, img_coord, 21)
        cls.search = rotate(cls.search, 0)
        cls.search = imresize(cls.search, 1.)
def test_cifi_radii_none_error(template, search):
    with pytest.raises(ValueError):
        ciratefi.cifi(template, search, 90, radii=None)

        cls.offset = (1, 1)
def test_cifi_scales_none_error(template, search):
    with pytest.raises(ValueError):
        ciratefi.cifi(template, search, 90, scales=None)

        cls.offset_template = sp.clip_roi(img, np.add(img_coord, cls.offset), 5)
        cls.offset_template = rotate(cls.offset_template, 0)
        cls.offset_template = imresize(cls.offset_template, 1.)
def test_cifi_template_too_large_error(template, search):
    with pytest.raises(ValueError):
        ciratefi.cifi(search,template, 90, scales=None)

        cls.search_center = [math.floor(cls.search.shape[0]/2),
                             math.floor(cls.search.shape[1]/2)]
@pytest.mark.parametrize('cifi_thresh, radii', [(90,list(range(1, 3)))])
def test_cifi(template, search, cifi_thresh, radii):
    pixels, scales = ciratefi.cifi(template, search, thresh=cifi_thresh,
                                   radii=radii, use_percentile=True)

        cls.upsampling = 10
        cls.alpha = math.pi/2
        cls.cifi_thresh = 90
        cls.rafi_thresh = 90
        cls.tefi_thresh = 100
        cls.use_percentile = True
        cls.radii = list(range(1, 3))
    assert search.shape == scales.shape
    assert (np.floor(search.shape[0]/2), np.floor(search.shape[1]/2)) in pixels
    assert pixels.size in range(0,search.size)

        cls.cifi_number_of_warnings = 2
        cls.rafi_number_of_warnings = 2

    def test_cifi(self):
            # check all warnings
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                ciratefi.cifi(self.template, self.search, 1.0, radii=[100], use_percentile=False)
                self.assertEqual(len(w), self.cifi_number_of_warnings)

            # Threshold out of bounds error
            self.assertRaises(ValueError, ciratefi.cifi, self.template, self.search, -1.1, use_percentile=False)
            # radii list empty/none error
            self.assertRaises(ValueError, ciratefi.cifi, self.template, self.search, 90, radii=None)
            # scales list empty/none error
            self.assertRaises(ValueError, ciratefi.cifi, self.template, self.search, 90, scales=None)
            # template is bigger than search error
            self.assertRaises(ValueError, ciratefi.cifi, self.search, self.template, -1.1, use_percentile=False)

            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                pixels, scales = ciratefi.cifi(self.template, self.search, thresh=self.cifi_thresh,
                                               radii=self.radii, use_percentile=True)

                self.assertEqual(len(w), 0)

                self.assertEqual(self.search.shape, scales.shape)
                self.assertIn((np.floor(self.search.shape[0]/2), np.floor(self.search.shape[1]/2)), pixels)
                self.assertTrue(pixels.size in range(0, self.search.size))

    def test_rafi(self):
def test_rafi_warning(template, search):
    rafi_pixels = [(10, 10)]

        rafi_scales = np.ones(self.search.shape, dtype=float)

        # check all warnings
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            ciratefi.rafi(self.template, self.search, rafi_pixels,
    rafi_scales = np.ones(search.shape, dtype=float)
    with pytest.warns(UserWarning):
        ciratefi.rafi(template, search, rafi_pixels,
              rafi_scales, thresh=1, radii=[100],
              use_percentile=False)

            self.assertEqual(len(w), self.rafi_number_of_warnings)

        # Threshold out of bounds error
        self.assertRaises(ValueError, ciratefi.rafi, self.template, self.search, rafi_pixels, rafi_scales,
                          -1.1, use_percentile=False)

        # Radii list is empty.None error
        self.assertRaises(ValueError, ciratefi.rafi, self.search, self.template, rafi_pixels, -1.1, radii=None)
        # candidate pixel list empty/none error
        self.assertRaises(ValueError, ciratefi.rafi, self.template, self.search, [], rafi_scales)
        # scales list empty/none error
        self.assertRaises(ValueError, ciratefi.rafi, self.template, self.search, rafi_pixels, None)
        # template is bigger than search error
        self.assertRaises(ValueError, ciratefi.rafi, self.search, self.template, rafi_pixels, rafi_scales)
        # best scale nd array is not equal image shape
        self.assertRaises(ValueError, ciratefi.rafi, self.template, self.search, rafi_pixels, rafi_scales[:10])

        with warnings.catch_warnings(record=True) as w:
            pixels, scales = ciratefi.rafi(self.template, self.search, rafi_pixels, rafi_scales,
                                           thresh=self.rafi_thresh, radii=self.radii, use_percentile=True,
                                           alpha=self.alpha)
            self.assertEqual(len(w), 0)

            self.assertIn((np.floor(self.search.shape[0]/2), np.floor(self.search.shape[1]/2)), pixels)
            self.assertTrue(pixels.size in range(0, self.search.size))

    def test_tefi(self):
        tefi_pixels = [(10, 10)]
        tefi_scales = np.ones(self.search.shape, dtype=float)
        tefi_angles = [3.14159265]

        # Threshold out of bounds error
        self.assertRaises(ValueError, ciratefi.tefi, self.template, self.search, tefi_pixels, tefi_scales,
                          tefi_angles, thresh=-1.1, use_percentile=False, alpha=self.alpha)
def test_rafi_bounds_error(template, search):
    rafi_pixels = [(10, 10)]
    rafi_scales = np.ones(search.shape, dtype=float)
    with pytest.raises(ValueError):
        ciratefi.rafi(template, search, rafi_pixels, rafi_scales, -1.1, use_percentile=False)

        # angle list is empty/None error
        self.assertRaises(ValueError, ciratefi.tefi, self.search, self.template, tefi_pixels, tefi_scales, None)
        # candidate pixel list empty/none error
        self.assertRaises(ValueError, ciratefi.tefi, self.template, self.search, None, tefi_scales, tefi_angles)
        # scales list empty/none error
        self.assertRaises(ValueError, ciratefi.tefi, self.template, self.search, tefi_pixels, None, tefi_angles)
        # template is bigger than search error
        self.assertRaises(ValueError, ciratefi.tefi, self.search, self.template, tefi_pixels, tefi_scales, -1.1)
        # best scale nd array is smaller than number of candidate pixels
        self.assertRaises(ValueError, ciratefi.tefi, self.template, self.search, tefi_pixels, tefi_scales[:10], -1.1)
def test_rafi_radii_list_none_error(template, search):
    rafi_pixels = [(10, 10)]
    with pytest.raises(ValueError):
        ciratefi.rafi(search, template, rafi_pixels, -1.1, radii=None)

        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            pixel = ciratefi.tefi(self.template, self.search, tefi_pixels, tefi_scales, tefi_angles,
                                           thresh=self.tefi_thresh, use_percentile=True, alpha=self.alpha,
                                           upsampling=self.upsampling)
def test_rafi_pixel_list_error(template, search):
    rafi_pixels = []
    rafi_scales = np.ones(search.shape, dtype=float)
    with pytest.raises(ValueError):
        ciratefi.rafi(template, search, rafi_pixels, rafi_scales)

            for warn in w:
                print(warn)
def test_rafi_scales_list_error(template, search):
    rafi_pixels = [(10, 10)]
    with pytest.raises(ValueError):
        ciratefi.rafi(template, search, rafi_pixels, None)

            self.assertEqual(len(w), 0)
            print(pixel)
            self.assertTrue(np.equal((.5, .5), (pixel[1], pixel[0])).all())
def test_rafi_template_bigger_error(template, search):
    rafi_pixels = [(10, 10)]
    rafi_scales = np.ones(search.shape, dtype=float)
    with pytest.raises(ValueError):
        ciratefi.rafi(search, template, rafi_pixels,rafi_scales)

    def test_ciratefi(self):
        results = ciratefi.ciratefi(self.template, self.search, upsampling=10, cifi_thresh=self.cifi_thresh,
                                    rafi_thresh=self.rafi_thresh, tefi_thresh=self.tefi_thresh,
                                    use_percentile=self.use_percentile, alpha=self.alpha, radii=self.radii)
def test_rafi_shape_mismatch(template, search):
        rafi_pixels = [(10, 10)]
        rafi_scales = np.ones(search.shape, dtype=float)[:10]
        with pytest.raises(ValueError):
            ciratefi.rafi(template, search, rafi_pixels, rafi_scales)

        self.assertEqual(len(results), 3)
        self.assertTrue((np.array(results[1], results[0]) < 1).all())
@pytest.mark.parametrize("rafi_thresh, radii, alpha", [(90, list(range(1, 3)),math.pi/2)])
def test_rafi(template, search, rafi_thresh, radii, alpha):
    rafi_pixels = [(10, 10)]
    rafi_scales = np.ones(search.shape, dtype=float)
    pixels, scales = ciratefi.rafi(template, search, rafi_pixels, rafi_scales,
                                   thresh=rafi_thresh, radii=radii, use_percentile=True,
                                   alpha=alpha)

    assert (np.floor(search.shape[0]/2), np.floor(search.shape[1]/2)) in pixels
    assert pixels.size in range(0, search.size)

# Alternate approach to the more verbose tests above - this tests all combinations
@pytest.mark.parametrize("tefi_pixels", [[(10,10)], None])
@pytest.mark.parametrize("tefi_scales", [np.ones(search(img(), img_coord()).shape, dtype=float),
                                         None,
                                         np.ones(search(img(), img_coord()).shape, dtype=float)[:10]])
@pytest.mark.parametrize("tefi_angles", [[3.14159265], None])
@pytest.mark.parametrize("thresh", [-1.1, 90])
@pytest.mark.parametrize("reverse", [False, True])
def test_tefi_errors(template, search, tefi_pixels, tefi_scales, tefi_angles, thresh, reverse):
    with pytest.raises(ValueError):
        if reverse:
            template, search = search, template
        ciratefi.tefi(template, search, tefi_pixels, tefi_scales,
                  tefi_angles, thresh=-1.1, use_percentile=False, alpha=math.pi/2)

def test_tefi(template, search):
    tefi_pixels = [(10, 10)]
    tefi_scales = np.ones(search.shape, dtype=float)
    tefi_angles = [3.14159265]

        results = ciratefi.ciratefi(self.offset_template, self.search, upsampling=self.upsampling,
                                    cifi_thresh=self.cifi_thresh, rafi_thresh=self.rafi_thresh,
                                    tefi_thresh=self.tefi_thresh,
                                    use_percentile=self.use_percentile, alpha=self.alpha, radii=self.radii)
    pixel = ciratefi.tefi(template, search, tefi_pixels, tefi_scales, tefi_angles,
                                   thresh=tefi_thresh, use_percentile=True, alpha=math.pi/2,
                                   upsampling=10)

    assert np.equal((.5, .5), (pixel[1], pixel[0])).all()

@pytest.mark.parametrize("cifi_thresh, rafi_thresh, tefi_thresh, alpha, radii",[(90,90,100,math.pi/2,list(range(1, 3)))])
def test_ciratefi(template, search, cifi_thresh, rafi_thresh, tefi_thresh, alpha, radii):
    results = ciratefi.ciratefi(template, search, upsampling=10, cifi_thresh=cifi_thresh,
                                rafi_thresh=rafi_thresh, tefi_thresh=tefi_thresh,
                                use_percentile=True, alpha=alpha, radii=radii)

    def tearDown(self):
        pass
    assert len(results) == 3
    assert (np.array(results[1], results[0]) < 1).all()
+7 −7
Changes for autocnet/matcher/tests/test_matcher.py: 7 added lines, 7 removed lines.
Original line number Diff line number Diff line
@@ -52,37 +52,37 @@ class TestMatcher(unittest.TestCase):
        edges = list()
        from autocnet.matcher.cpu_matcher import match as match
        for s, d in cang.edges():
            cang[s][d]._match = match
            cang[s][d]['data']._match = match
            edges.append(cang[s][d])

        # Assert none of the edges have masks yet
        for edge in edges:
            self.assertTrue(edge.masks.empty)
            self.assertTrue(edge['data'].masks.empty)

        # Match & outlier detect
        cang.match()
        cang.symmetry_checks()

        # Grab the length of a matches df
        match_len = len(edges[0].matches.index)
        match_len = len(edges[0]['data'].matches.index)

        # Assert symmetry check is now in all edge masks
        for edge in edges:
            self.assertTrue('symmetry' in edge.masks)
            self.assertTrue('symmetry' in edge['data'].masks)

        # Assert matches have been populated
        for edge in edges:
            self.assertTrue(not edge.matches.empty)
            self.assertTrue(not edge['data'].matches.empty)

        # Re-match
        cang.match()

        # Assert that new matches have been added on to old ones
        self.assertEqual(len(edges[0].matches.index), match_len * 2)
        self.assertEqual(len(edges[0]['data'].matches.index), match_len * 2)

        # Assert that the match cleared the masks df
        for edge in edges:
            self.assertTrue(edge.masks.empty)
            self.assertTrue(edge['data'].masks.empty)


    def tearDown(self):
+2 −2
Changes for bin/image_match.py: 2 added lines, 2 removed lines.
Original line number Diff line number Diff line
@@ -8,8 +8,8 @@ sys.path.insert(0, os.path.abspath('../autocnet'))

from autocnet.utils.utils import find_in_dict
from autocnet.graph.network import CandidateGraph
from autocnet.fileio.io_controlnetwork import to_isis, write_filelist
from autocnet.fileio.io_yaml import read_yaml
#from autocnet.fileio.io_controlnetwork import to_isis, write_filelist
#from autocnet.fileio.io_yaml import read_yaml


def parse_arguments():