vtool-ibeis 2.2.1__py3-none-any.whl → 2.3.1__py3-none-any.whl

vtool_ibeis/image_filters.py

@@ -14,7 +14,8 @@ class IntensityPreproc(object):
     Doctest:
         >>> from vtool_ibeis.image_filters import *
         >>> import vtool_ibeis as vt
-        >>> chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> #chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> chipBGR = vt.imread(ut.grab_test_imgpath('astro'))
         >>> filter_list = [
         >>>     ('medianblur', {}),
         >>>     ('adapteq', {}),
@@ -71,7 +72,9 @@ def manta_matcher_filters(chipBGR):
         >>> from ibeis.core_annots import *  # NOQA
         >>> import ibeis
         >>> ibs = ibeis.opendb('Mantas')
-        >>> chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> #chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> chipBGR = vt.imread(ut.grab_test_imgpath('astro'))
+
     """
     chipLAB = cv2.cvtColor(chipBGR, cv2.COLOR_BGR2LAB)
 
@@ -99,7 +102,8 @@ def adapteq_fn(chipBGR):
         >>> from vtool_ibeis.image_filters import *
         >>> import vtool_ibeis as vt
         >>> import utool as ut
-        >>> chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> #chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> chipBGR = vt.imread(ut.grab_test_imgpath('astro'))
         >>> chip2 = adapteq_fn(chipBGR)
         >>> # xdoctest: +REQUIRES(--show)
         >>> import plottool_ibeis as pt
@@ -124,8 +128,9 @@ def medianfilter_fn(chipBGR):
         >>> from vtool_ibeis.image_filters import *
         >>> import vtool_ibeis as vt
         >>> import utool as ut
-        >>> chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
-        >>> chip2 = adapteq_fn(chipBGR)
+        >>> #chipBGR = vt.imread(ut.grab_file_url('http://i.imgur.com/qVWQaex.jpg'))
+        >>> chipBGR = vt.imread(ut.grab_test_imgpath('astro'))
+        >>> chip2 = medianfilter_fn(chipBGR)
         >>> # xdoctest: +REQUIRES(--show)
         >>> import plottool_ibeis as pt
         >>> pt.imshow(chipBGR, pnum=(1, 2, 1), fnum=1)
@@ -199,7 +204,6 @@ def grabcut_fn(chipBGR):
     return seg_chipBGR
 
 
-
 if __name__ == '__main__':
     """
     CommandLine:

vtool_ibeis/inspect_matches.py

@@ -1,5 +1,7 @@
-import utool as ut
+#!/usr/bin/env python3
+import scriptconfig as scfg
 import ubelt as ub
+import utool as ut
 try:
     import guitool_ibeis as gt
     from guitool_ibeis import mpl_widget
@@ -69,8 +71,8 @@ class MatchInspector(INSPECT_BASE):
         >>> import vtool_ibeis as vt
         >>> gt.ensure_qapp()
         >>> ut.qtensure()
-        >>> annot1 = lazy_test_annot('easy1.png')
-        >>> annot2 = lazy_test_annot('easy2.png')
+        >>> annot1 = lazy_test_annot('tsukuba_r')
+        >>> annot2 = lazy_test_annot('tsukuba_l')
         >>> match = vt.PairwiseMatch(annot1, annot2)
         >>> self = MatchInspector(match=match)
         >>> self.show()
@@ -345,10 +347,45 @@ def show_matching_dict(matches, metadata, *args, **kwargs):
     return interact
 
 
+class InspectMatchesCLI(scfg.DataConfig):
+    """
+    Run a 1vs1 matching
+    """
+    img1 = scfg.Value('tsukuba_r', type=str, position=1, help='key or path of test image 1')
+    img2 = scfg.Value('tsukuba_l', type=str, position=2, help='key or path of test image 2')
+
+    @classmethod
+    def main(cls, argv=1, **kwargs):
+        """
+        Example:
+            >>> # xdoctest: +SKIP
+            >>> from vtool_ibeis.inspect_matches import *  # NOQA
+            >>> argv = 0
+            >>> kwargs = dict()
+            >>> cls = InspectMatchesCLI
+            >>> config = cls(**kwargs)
+            >>> cls.main(argv=argv, **config)
+        """
+        import vtool_ibeis as vt
+        config = cls.cli(argv=argv, data=kwargs, strict=True, verbose='auto')
+        gt.ensure_qapp()
+        ut.qtensure()
+        annot1 = lazy_test_annot(config.img1)
+        annot2 = lazy_test_annot(config.img2)
+        match = vt.PairwiseMatch(annot1, annot2)
+        self = MatchInspector(match=match)
+        self.show()
+        # xdoctest: +REQUIRES(--show)
+        #self.update()
+        gt.qtapp_loop(qwin=self, freq=10)
+
+__cli__ = InspectMatchesCLI
+
 if __name__ == '__main__':
     """
+
     CommandLine:
-        xdoctest -m vtool_ibeis.inspect_matches
+        python ~/code/vtool_ibeis/vtool_ibeis/inspect_matches.py
+        python -m vtool_ibeis.inspect_matches /home/joncrall/Downloads/tmp/ibeis/IMG_0070_A.JPG /home/joncrall/Downloads/tmp/ibeis/IMG_0315_A.JPG
     """
-    import xdoctest
-    xdoctest.doctest_module(__file__)
+    __cli__.main()

vtool_ibeis/keypoint.py

@@ -659,7 +659,7 @@ def get_transforms_from_patch_image_kpts(kpts, patch_shape, scale_factor=1.0):
         %timeit np.array([S2.dot(A) for A in invVR_aff2Ds])
         %timeit op.matmul(S2, invVR_aff2Ds)
 
-        from six.moves import reduce
+        from functools import reduce
         perspective_list2 = np.array([S2.dot(A).dot(S1).dot(T1) for A in invVR_aff2Ds])
         perspective_list = reduce(op.matmul, (S2, invVR_aff2Ds, S1, T1))
         assert np.all(perspective_list == perspective_list2)

vtool_ibeis/matching.py

@@ -102,13 +102,13 @@ def demodata_match(cfgdict={}, apply=True, use_cache=True, recompute=False):
     cfgstr = ub.hash_data(cfgdict) + hashid
     cacher = ub.Cacher(
         'test_match_v5',
-        cfgstr=cfgstr,
+        depends=cfgstr,
         appname='vtool_ibeis',
         enabled=use_cache
     )
     match = cacher.tryload()
-    annot1 = lazy_test_annot('easy1.png')
-    annot2 = lazy_test_annot('easy2.png')
+    annot1 = lazy_test_annot('tsukuba_l')
+    annot2 = lazy_test_annot('tsukuba_r')
     if match is None or recompute:
         match = vt.PairwiseMatch(annot1, annot2)
         if apply:
@@ -141,8 +141,10 @@ class PairwiseMatch(ub.NiceRepr):
         >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.matching import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> imgR = vt.imread(ut.grab_test_imgpath('easy1.png'))
-        >>> imgL = vt.imread(ut.grab_test_imgpath('easy2.png'))
+        >>> #imgR = vt.imread(ut.grab_test_imgpath('easy1.png'))
+        >>> #imgL = vt.imread(ut.grab_test_imgpath('easy2.png'))
+        >>> imgR = vt.imread(ut.grab_test_imgpath('tsukuba_r'))
+        >>> imgL = vt.imread(ut.grab_test_imgpath('tsukuba_l'))
         >>> annot1 = {'rchip': imgR}
         >>> annot2 = {'rchip': imgL}
         >>> match = vt.PairwiseMatch(annot1, annot2)
@@ -162,8 +164,8 @@ class PairwiseMatch(ub.NiceRepr):
         >>> match.ishow()
         >>> from vtool_ibeis.matching import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> imgR = vt.imread(ut.grab_test_imgpath('easy1.png'))
-        >>> imgL = vt.imread(ut.grab_test_imgpath('easy2.png'))
+        >>> imgR = vt.imread(ut.grab_test_imgpath('tsukuba_r'))
+        >>> imgL = vt.imread(ut.grab_test_imgpath('tsukuba_l'))
         >>> annot1 = {'rchip': imgR}
         >>> annot2 = {'rchip': imgL}
         >>> match = vt.PairwiseMatch(annot1, annot2)
@@ -453,8 +455,10 @@ class PairwiseMatch(ub.NiceRepr):
         K, Knorm, symmetric, checks, weight_key = params
         annot1 = match.annot1
         annot2 = match.annot2
+        if verbose is None:
+            verbose = match.verbose
 
-        if match.verbose:
+        if verbose:
             print('[match] assign')
             print('[match] params = ' + ub.repr2(params))
 
@@ -1447,7 +1451,7 @@ def ensure_metadata_feats(annot, cfgdict={}):
         >>> # ENABLE_DOCTEST
         >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.matching import *  # NOQA
-        >>> rchip_fpath = ut.grab_test_imgpath('easy1.png')
+        >>> rchip_fpath = ut.grab_test_imgpath('astro')
         >>> annot = ut.LazyDict({'rchip_fpath': rchip_fpath})
         >>> cfgdict = {}
         >>> ensure_metadata_feats(annot, cfgdict)

vtool_ibeis/nearest_neighbors.py

@@ -109,8 +109,10 @@ def test_cv2_flann():
     from vtool_ibeis import demodata
     import plottool_ibeis as pt
     import vtool_ibeis as vt
-    img1 = vt.imread(ut.grab_test_imgpath('easy1.png'))
-    img2 = vt.imread(ut.grab_test_imgpath('easy2.png'))
+    # img1 = vt.imread(ut.grab_test_imgpath('easy1.png'))
+    # img2 = vt.imread(ut.grab_test_imgpath('easy2.png'))
+    img1 = vt.imread(ut.grab_test_imgpath('tsukuba_l'))
+    img2 = vt.imread(ut.grab_test_imgpath('tsukuba_r'))
 
     stereo = cv2.StereoBM_create(numDisparities=16, blockSize=15)
     disparity = stereo.compute(img1, img2)

vtool_ibeis/other.py

@@ -1266,9 +1266,14 @@ def intersect2d_numpy(A, B, assume_unique=False, return_indices=False):
         >>> C, Ax, Bx = intersect2d_numpy(A, B, return_indices=True)
         >>> # verify results
         >>> result = str((C.T, Ax, Bx))
-        >>> print(result)
-        (array([[ 85, 403, 412],
-               [ 32,  22, 103]]), array([2, 6, 7]), array([0, 1, 2]))
+        >>> import ubelt as ub
+        >>> print(f'C.T = {ub.urepr(C.T, nl=1, with_dtype=False)}')
+        >>> print(f'Ax = {ub.urepr(Ax, nl=1, with_dtype=False)}')
+        >>> print(f'Bx = {ub.urepr(Bx, nl=1, with_dtype=False)}')
+        C.T = np.array([[ 85, 403, 412],
+                  [ 32,  22, 103]])
+        Ax = np.array([2, 6, 7])
+        Bx = np.array([0, 1, 2])
 
     Example2:
         >>> # ENABLE_DOCTEST
@@ -1276,9 +1281,15 @@ def intersect2d_numpy(A, B, assume_unique=False, return_indices=False):
         >>> A = np.array([[1, 2, 3], [1, 1, 1]])
         >>> B = np.array([[1, 2, 3], [1, 2, 14]])
         >>> C, Ax, Bx = intersect2d_numpy(A, B, return_indices=True)
-        >>> result = str((C, Ax, Bx))
-        >>> print(result)
-        (array([[1, 2, 3]]), array([0]), array([0]))
+        >>> import ubelt as ub
+        >>> print(f'C.T = {ub.urepr(C.T, nl=1, with_dtype=False)}')
+        >>> print(f'Ax = {ub.urepr(Ax, nl=1, with_dtype=False)}')
+        >>> print(f'Bx = {ub.urepr(Bx, nl=1, with_dtype=False)}')
+        C.T = np.array([[1],
+                  [2],
+                  [3]])
+        Ax = np.array([0])
+        Bx = np.array([0])
     """
     nrows, ncols = A.shape
     A_, B_, C_ = intersect2d_structured_numpy(A, B, assume_unique)
@@ -1672,12 +1683,13 @@ def find_first_true_indices(flags_list):
         >>> index_list = find_first_true_indices(flags_list)
         >>> # verify results
         >>> result = str(index_list)
-        >>> print(result)
-        [0, None, 1, 2]
+        >>> import ubelt as ub
+        >>> print(f'result = {ub.urepr(result, nl=1)}')
+        result = '[0, None, 1, 2]'
     """
     def tryget_fisrt_true(flags):
         index_list = np.where(flags)[0]
-        index = None if len(index_list) == 0 else index_list[0]
+        index = None if len(index_list) == 0 else int(index_list[0])
         return index
     index_list = [tryget_fisrt_true(flags) for flags in flags_list]
     return index_list
@@ -1691,9 +1703,6 @@ def find_k_true_indicies(flags_list, k):
     Args:
         flags_list (list): list of lists of booleans
 
-    CommandLine:
-        python -m utool.util_list --test-find_next_true_indices
-
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.other import *  # NOQA
@@ -1703,9 +1712,14 @@ def find_k_true_indicies(flags_list, k):
         ...               [True, True, True]]
         >>> k = 2
         >>> indices = find_k_true_indicies(flags_list, k)
-        >>> result = str(indices)
-        >>> print(result)
-        [array([2]), None, array([1, 2]), array([0, 1])]
+        >>> import ubelt as np
+        >>> print(f'result = {ub.urepr(indices, nl=1, with_dtype=False)}')
+        result = [
+            np.array([2]),
+            None,
+            np.array([1, 2]),
+            np.array([0, 1]),
+        ]
     """
 
     if False:
@@ -1733,7 +1747,7 @@ def find_next_true_indices(flags_list, offset_list):
         flags_list (list): list of lists of booleans
 
     CommandLine:
-        python -m utool.util_list --test-find_next_true_indices
+        xdoctest vtool_ibeis.other find_next_true_indices
 
     Example:
         >>> # ENABLE_DOCTEST
@@ -1747,15 +1761,15 @@ def find_next_true_indices(flags_list, offset_list):
         >>> # execute function
         >>> index_list = find_next_true_indices(flags_list, offset_list)
         >>> # verify results
-        >>> result = str(index_list)
-        >>> print(result)
-        [2, None, 2, None]
+        >>> import ubelt as ub
+        >>> print(f'index_list = {ub.urepr(index_list, nl=0)}')
+        index_list = [2, None, 2, None]
     """
     def tryget_next_true(flags, offset_):
         offset = offset_ + 1
         relative_flags = flags[offset:]
         rel_index_list = np.where(relative_flags)[0]
-        index = None if len(rel_index_list) == 0 else rel_index_list[0] + offset
+        index = None if len(rel_index_list) == 0 else int(rel_index_list[0] + offset)
         return index
     index_list = [None if offset is None else tryget_next_true(flags, offset)
                   for flags, offset in zip(flags_list, offset_list)]

vtool_ibeis/patch.py

@@ -570,7 +570,7 @@ def get_warped_patches(img, kpts, flags=cv2.INTER_LANCZOS4,
         >>> from vtool_ibeis.patch import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('carl')
         >>> img = vt.imread(img_fpath)
         >>> use_cpp = ut.get_argflag('--use_cpp')
         >>> kpts, desc = vt.extract_features(img_fpath)
@@ -1065,18 +1065,14 @@ def draw_kp_ori_steps():
         >>> draw_kp_ori_steps()
         >>> pt.show_if_requested()
     """
-    #from vtool_ibeis.patch import *  # NOQA
-    #import vtool_ibeis as vt
     # build test data
     import utool as ut
     import plottool_ibeis as pt
-    import vtool_ibeis as vt
 
     if True:
         from ibeis.scripts.thesis import TMP_RC
         import matplotlib as mpl
         mpl.rcParams.update(TMP_RC)
-    #import vtool_ibeis as vt
     np.random.seed(0)
     USE_COMMANLINE = True
     if USE_COMMANLINE:
@@ -1085,24 +1081,16 @@ def draw_kp_ori_steps():
         kp = kpts[fx]
     else:
         fx = 0
-        USE_EXTERN_STAR = False
-        if USE_EXTERN_STAR:
-            img_fpath = ut.grab_test_imgpath('star.png')
-            imgBGR = vt.imread(img_fpath)
-            kpts, vecs = vt.extract_features(img_fpath)
-            kp = np.array([  3.14742985e+01,   2.95660381e+01,   1.96057682e+01, -5.11199608e-03,   2.05653343e+01,   0.00000000e+00],
-                          dtype=np.float32)
-        else:
-            #imgBGR = get_test_patch('stripe', jitter=True)
-            #imgBGR = get_test_patch('star', jitter=True)
-            imgBGR = get_test_patch('star2', jitter=True)
-            #imgBGR = get_test_patch('cross', jitter=False)
-            #imgBGR = cv2.resize(imgBGR, (41, 41), interpolation=cv2.INTER_LANCZOS4)
-            imgBGR = cv2.resize(imgBGR, (41, 41), interpolation=cv2.INTER_CUBIC)
-            theta = 0  # 3.4  # TAU / 16
-            #kpts = make_test_image_keypoints(imgBGR, scale=.9, theta=theta)
-            kpts = make_test_image_keypoints(imgBGR, scale=.3, theta=theta, shift=(.3, .1))
-            kp = kpts[0]
+        #imgBGR = get_test_patch('stripe', jitter=True)
+        #imgBGR = get_test_patch('star', jitter=True)
+        imgBGR = get_test_patch('star2', jitter=True)
+        #imgBGR = get_test_patch('cross', jitter=False)
+        #imgBGR = cv2.resize(imgBGR, (41, 41), interpolation=cv2.INTER_LANCZOS4)
+        imgBGR = cv2.resize(imgBGR, (41, 41), interpolation=cv2.INTER_CUBIC)
+        theta = 0  # 3.4  # TAU / 16
+        #kpts = make_test_image_keypoints(imgBGR, scale=.9, theta=theta)
+        kpts = make_test_image_keypoints(imgBGR, scale=.3, theta=theta, shift=(.3, .1))
+        kp = kpts[0]
     bins = 36
     maxima_thresh = .8
     converge_lists = []

vtool_ibeis/quality_classifier.py

@@ -19,7 +19,7 @@ def compute_average_contrast(img):
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.quality_classifier import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('carl')
         >>> img = vt.imread(img_fpath, grayscale=True)
         >>> average_contrast, gradmag_sqrd = compute_average_contrast(img)
         >>> # xdoctest: +REQUIRES(module:plottool_ibeis)
@@ -104,7 +104,7 @@ def fourier_devtest(img):
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.quality_classifier import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('carl')
         >>> img = vt.imread(img_fpath, grayscale=True)
         >>> magnitude_spectrum = fourier_devtest(img)
     """

vtool_ibeis/score_normalization.py

@@ -25,17 +25,22 @@ def testdata_score_normalier(tp_bumps=[(6.5, 256)], tn_bumps=[(3.5, 256)], tp_sc
     encoder.fit(data, labels)
     return encoder, data, labels
 
+try:
+    _trapz = np.trapz
+except Exception:
+    _trapz = np.trapezoid
+
 
 def get_left_area(ydata, xdata, index_list):
     """ area to the left of each index point """
-    left_area = np.array([np.trapz(ydata[:ix + 1], xdata[:ix + 1])
+    left_area = np.array([_trapz(ydata[:ix + 1], xdata[:ix + 1])
                           for ix in index_list])
     return left_area
 
 
 def get_right_area(ydata, xdata, index_list):
     """ area to the right of each index point """
-    right_area = np.array([np.trapz(ydata[ix:], xdata[ix:])
+    right_area = np.array([_trapz(ydata[ix:], xdata[ix:])
                            for ix in index_list])
     return right_area
 
@@ -207,7 +212,7 @@ class ScoreNormalizer(ut.Cachable, ScoreNormVisualizeClass):
             >>> # ENABLE_DOCTEST
             >>> from vtool_ibeis.score_normalization import *  # NOQA
             >>> encoder = ScoreNormalizer()
-            >>> from six.moves import cPickle as pickle
+            >>> import pickle
             >>> dump = pickle.dumps(encoder)
             >>> encoder2 = pickle.loads(dump)
         """
@@ -1017,8 +1022,8 @@ def learn_score_normalization(tp_support, tn_support, gridsize=1024, adjust=8,
 
     if True:
         # Make sure we still have probability functions
-        area_tp = np.trapz(p_score_given_tp, score_domain)
-        area_tn = np.trapz(p_score_given_tn, score_domain)
+        area_tp = _trapz(p_score_given_tp, score_domain)
+        area_tn = _trapz(p_score_given_tn, score_domain)
         if verbose:
             print('pre.area_tp = %r' % (area_tp,))
             print('pre.area_tn = %r' % (area_tn,))
@@ -1027,8 +1032,8 @@ def learn_score_normalization(tp_support, tn_support, gridsize=1024, adjust=8,
         p_score_given_tp = p_score_given_tp / area_tp
         p_score_given_tn = p_score_given_tn / area_tn
 
-        area_tp = np.trapz(p_score_given_tp, score_domain)
-        area_tn = np.trapz(p_score_given_tn, score_domain)
+        area_tp = _trapz(p_score_given_tp, score_domain)
+        area_tn = _trapz(p_score_given_tn, score_domain)
         #if ut.DEBUG2:
         if verbose:
             print('norm.area_tp = %r' % (area_tp,))
@@ -1055,12 +1060,12 @@ def learn_score_normalization(tp_support, tn_support, gridsize=1024, adjust=8,
     # Apply bayes
     p_tp_given_score = ut.bayes_rule(p_score_given_tp, p_tp, p_score)
     if ut.DEBUG2:
-        assert np.isclose(np.trapz(p_score, score_domain), 1.0)
-        assert np.isclose(np.trapz(p_score, p_tp_given_score), 1.0)
+        assert np.isclose(_trapz(p_score, score_domain), 1.0)
+        assert np.isclose(_trapz(p_score, p_tp_given_score), 1.0)
     if np.any(np.isnan(p_tp_given_score)):
         p_tp_given_score = vt.interpolate_nans(p_tp_given_score)
     if verbose:
-        # np.trapz(p_tp_given_score / np.trapz(p_tp_given_score, score_domain), score_domain)
+        # _trapz(p_tp_given_score / _trapz(p_tp_given_score, score_domain), score_domain)
         print('stats:p_score_given_tn = ' + ut.get_stats_str(p_score_given_tn, newlines=0, use_nan=True, precision=5))
         print('stats:p_score_given_tp = ' + ut.get_stats_str(p_score_given_tp, newlines=0, use_nan=True, precision=5))
         print('stats:p_score = ' + ut.get_stats_str(p_score, newlines=0, use_nan=True, precision=5))

vtool_ibeis/segmentation.py

@@ -85,7 +85,7 @@ def demo_grabcut(bgr_img):
         >>> import utool as ut
         >>> import plottool_ibeis as pt
         >>> import vtool_ibeis as vt
-        >>> img_fpath = ut.grab_test_imgpath('easy1.png')
+        >>> img_fpath = ut.grab_test_imgpath('astro')
         >>> bgr_img = vt.imread(img_fpath)
         >>> # execute function
         >>> print(bgr_img.shape)

vtool_ibeis/spatial_verification.py

@@ -374,8 +374,8 @@ def testdata_matching_affine_inliers():
     ori_thresh = 1.57
     xy_thresh_sqrd = dlen_sqrd2 * xy_thresh
     featkw = ut.argparse_dict(vt.get_extract_features_default_params())
-    fname1 = ut.get_argval('--fname1', type_=str, default='easy1.png')
-    fname2 = ut.get_argval('--fname2', type_=str, default='easy2.png')
+    fname1 = ut.get_argval('--fname1', type_=str, default='tsukuba_l')
+    fname2 = ut.get_argval('--fname2', type_=str, default='tsukuba_r')
     (kpts1, kpts2, fm, fs, rchip1, rchip2) = demodata.testdata_ratio_matches(fname1, fname2, **featkw)
     aff_inliers, aff_errors, Aff = get_best_affine_inliers_(
         kpts1, kpts2, fm, fs, xy_thresh_sqrd, scale_thresh, ori_thresh)
@@ -958,8 +958,8 @@ def spatially_verify_kpts(kpts1, kpts2, fm,
         >>> from vtool_ibeis.spatial_verification import *
         >>> import vtool_ibeis.demodata as demodata
         >>> import vtool_ibeis as vt
-        >>> fname1 = ut.get_argval('--fname1', type_=str, default='easy1.png')
-        >>> fname2 = ut.get_argval('--fname2', type_=str, default='easy2.png')
+        >>> fname1 = ut.get_argval('--fname1', type_=str, default='tsukuba_r')
+        >>> fname2 = ut.get_argval('--fname2', type_=str, default='tsukuba_l')
         >>> default_dict = vt.get_extract_features_default_params()
         >>> default_dict['ratio_thresh'] = .625
         >>> kwargs = ut.argparse_dict(default_dict)
@@ -993,8 +993,6 @@ def spatially_verify_kpts(kpts1, kpts2, fm,
         >>> aff_tup = (aff_inliers, Aff)
         >>> pt.draw_sv.show_sv(rchip1, rchip2, kpts1, kpts2, fm, aff_tup=aff_tup, homog_tup=homog_tup, refine_method=refine_method)
         >>> pt.show_if_requested()
-        tuple(numpy.ndarray, tuple(numpy.ndarray*3), numpy.ndarray, numpy.ndarray, tuple(numpy.ndarray*3), numpy.ndarray)
-
     """
     if len(fm) == 0:
         if VERBOSE_SVER:

vtool_ibeis/symbolic.py

@@ -2,7 +2,6 @@
 Sympy helpers
 """
 import numpy as np
-import six
 import utool as ut
 import ubelt as ub
 
@@ -38,7 +37,7 @@ def evalprint(str_, globals_=None, locals_=None, simplify=False):
         globals_ = ut.get_parent_frame().f_globals
     if locals_ is None:
         locals_ = ut.get_parent_frame().f_locals
-    if isinstance(str_, six.string_types):
+    if isinstance(str_, str):
         var = eval(str_, globals_, locals_)
     else:
         var = str_
@@ -72,9 +71,9 @@ def check_expr_eq(expr1, expr2, verbose=True):
         >>> print(result)
     """
     import sympy
-    if isinstance(expr1, six.string_types):
+    if isinstance(expr1, str):
         expr1 = sympy.simplify(expr1)
-    if isinstance(expr2, six.string_types):
+    if isinstance(expr2, str):
         expr2 = sympy.simplify(expr2)
     print(ub.hzcat('Checking if ', repr(expr1), ' == ', repr(expr2)))
     random_point_check = expr1.equals(expr2)