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

vtool_ibeis/__init__.py

@@ -5,7 +5,7 @@ Autogenerate Command:
     mkinit vtool_ibeis -i
 """
 # flake8: noqa
-__version__ = '2.2.1'
+__version__ = '2.3.0'
 __author__ = 'Jon Crall, Avi Weinstock, Chuck Stewart, Hendrik Weideman, Jason Parham, Zackary Rutfield'
 __author_email__ = 'erotemic@gmail.com'
 __url__ = 'https://github.com/Erotemic/vtool_ibeis'

vtool_ibeis/blend.py

@@ -5,7 +5,7 @@ import ubelt as ub
 
 def testdata_blend(scale=128):
     import vtool_ibeis as vt
-    img_fpath = ut.grab_test_imgpath('lena.png')
+    img_fpath = ut.grab_test_imgpath('astro')
     img1 = vt.imread(img_fpath)
     rng = np.random.RandomState(0)
     img2 = vt.perlin_noise(img1.shape[0:2], scale=scale, rng=rng)[None, :].T

vtool_ibeis/coverage_grid.py

@@ -34,7 +34,7 @@ def make_grid_coverage_mask(kpts, chipsize, weights, pxl_per_bin=4,
         >>> from vtool_ibeis.coverage_grid import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> kpts, chipsize, weights = coverage_kpts.testdata_coverage('easy1.png')
+        >>> kpts, chipsize, weights = coverage_kpts.testdata_coverage('tsukuba_l')
         >>> pxl_per_bin = 4
         >>> grid_steps = 2
         >>> # execute function
@@ -323,7 +323,7 @@ def gridsearch_coverage_grid_mask():
     """
     import plottool_ibeis as pt
     cfgdict_list, cfglbl_list = get_coverage_grid_gridsearch_configs()
-    kpts, chipsize, weights = coverage_kpts.testdata_coverage('easy1.png')
+    kpts, chipsize, weights = coverage_kpts.testdata_coverage('astro')
     gridmask_list = [
         255 *  make_grid_coverage_mask(kpts, chipsize, weights, **cfgdict)
         for cfgdict in ub.ProgIter(cfgdict_list, desc='coverage grid')

vtool_ibeis/coverage_kpts.py

@@ -37,7 +37,7 @@ def make_kpts_heatmask(kpts, chipsize, cmap='plasma'):
         >>> from vtool_ibeis.coverage_kpts import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> import pyhesaff
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('carl')
         >>> (kpts, vecs) = pyhesaff.detect_feats(img_fpath)
         >>> chip = vt.imread(img_fpath)
         >>> kpts = kpts[0:100]
@@ -129,7 +129,7 @@ def make_kpts_coverage_mask(
         >>> import vtool_ibeis as vt
         >>> import plottool_ibeis as pt
         >>> import pyhesaff
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('carl')
         >>> (kpts, vecs) = pyhesaff.detect_feats(img_fpath)
         >>> kpts = kpts[::10]
         >>> chip = vt.imread(img_fpath)
@@ -210,7 +210,7 @@ def warp_patch_onto_kpts(
         >>> from vtool_ibeis.coverage_kpts import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> import pyhesaff
-        >>> img_fpath    = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath    = ut.grab_test_imgpath('carl')
         >>> (kpts, vecs) = pyhesaff.detect_feats(img_fpath)
         >>> kpts = kpts[::15]
         >>> chip = vt.imread(img_fpath)
@@ -434,7 +434,8 @@ def gridsearch_kpts_coverage_mask():
     """
     import plottool_ibeis as pt
     cfgdict_list, cfglbl_list = get_coverage_kpts_gridsearch_configs()
-    kpts, chipsize, weights = testdata_coverage('easy1.png')
+    # kpts, chipsize, weights = testdata_coverage('easy1.png')
+    kpts, chipsize, weights = testdata_coverage('astro')
     imgmask_list = [
         255 *  make_kpts_coverage_mask(kpts, chipsize, weights,
                                        return_patch=False, **cfgdict)
@@ -459,18 +460,18 @@ def testdata_coverage(fname=None):
     # build test data
     kpts, vecs = vt.demodata.get_testdata_kpts(fname, with_vecs=True)
     # HACK IN DISTINCTIVENESS
-    if fname is not None:
-        from ibeis.algo.hots import distinctiveness_normalizer
-        cachedir = ub.ensure_app_cache_dir('ibeis', 'distinctiveness_model')
-        species = 'zebra_plains'
-        dstcnvs_normer = distinctiveness_normalizer.DistinctivnessNormalizer(species, cachedir=cachedir)
-        dstcnvs_normer.load(cachedir)
-        weights = dstcnvs_normer.get_distinctiveness(vecs)
-    else:
-        kpts = np.vstack((kpts, [0, 0, 1, 1, 1, 0]))
-        kpts = np.vstack((kpts, [0.01, 10, 1, 1, 1, 0]))
-        kpts = np.vstack((kpts, [0.94, 11.5, 1, 1, 1, 0]))
-        weights = np.ones(len(kpts))
+    # if fname is not None:
+    #     from ibeis.algo.hots import distinctiveness_normalizer
+    #     cachedir = ub.ensure_app_cache_dir('ibeis', 'distinctiveness_model')
+    #     species = 'zebra_plains'
+    #     dstcnvs_normer = distinctiveness_normalizer.DistinctivnessNormalizer(species, cachedir=cachedir)
+    #     dstcnvs_normer.load(cachedir)
+    #     weights = dstcnvs_normer.get_distinctiveness(vecs)
+    # else:
+    kpts = np.vstack((kpts, [0, 0, 1, 1, 1, 0]))
+    kpts = np.vstack((kpts, [0.01, 10, 1, 1, 1, 0]))
+    kpts = np.vstack((kpts, [0.94, 11.5, 1, 1, 1, 0]))
+    weights = np.ones(len(kpts))
     chipsize = tuple(vt.iceil(vt.get_kpts_image_extent(kpts)[2:4]).tolist())
     return kpts, chipsize, weights
 

vtool_ibeis/demodata.py

@@ -633,7 +633,7 @@ def get_testdata_kpts(fname=None, with_vecs=False):
         return kpts
 
 
-def testdata_ratio_matches(fname1='easy1.png', fname2='easy2.png', **kwargs):
+def testdata_ratio_matches(fname1='tsukuba_r', fname2='tsukuba_l', **kwargs):
     r"""
     Runs simple ratio-test matching between two images.
     Technically this is not demodata data.
@@ -659,8 +659,8 @@ def testdata_ratio_matches(fname1='easy1.png', fname2='easy2.png', **kwargs):
         >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.demodata import *  # NOQA
         >>> 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_l')
+        >>> fname2 = ut.get_argval('--fname2', type_=str, default='tsukuba_r')
         >>> default_dict = vt.get_extract_features_default_params()
         >>> default_dict['ratio_thresh'] = .625
         >>> kwargs = ut.argparse_dict(default_dict)

vtool_ibeis/features.py

@@ -41,7 +41,7 @@ def extract_features(img_or_fpath, feat_type='hesaff+sift', **kwargs):
         >>> from vtool_ibeis.features import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img_fpath = ut.grab_test_imgpath(ut.get_argval('--fname', default='lena.png'))
+        >>> img_fpath = ut.grab_test_imgpath(ut.get_argval('--fname', default='astro'))
         >>> imgBGR = vt.imread(img_fpath)
         >>> feat_type = ub.argval('--feat_type', default='hesaff+sift')
         >>> import pyhesaff
@@ -109,8 +109,7 @@ def detect_opencv_keypoints():
     import vtool_ibeis as vt
     import numpy as np  # NOQA
 
-    #img_fpath = ut.grab_test_imgpath(ub.argval('--fname', default='lena.png'))
-    img_fpath = ut.grab_test_imgpath(ub.argval('--fname', default='zebra.png'))
+    img_fpath = ut.grab_test_imgpath(ub.argval('--fname', default='astro'))
     imgBGR = vt.imread(img_fpath)
     imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY)
 
@@ -251,7 +250,7 @@ def test_mser():
             info = {key: list(ub.compress(val, flags)) for key, val in self.info.items()}
             return Keypoints(subarr, info)
 
-    img_fpath = ut.grab_test_imgpath(ub.argval('--fname', default='zebra.png'))
+    img_fpath = ut.grab_test_imgpath(ub.argval('--fname', default='astro'))
     imgBGR = vt.imread(img_fpath)
     imgGray = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2GRAY)
     # http://docs.opencv.org/master/d3/d28/classcv_1_1MSER.html#gsc.tab=0

vtool_ibeis/geometry.py

@@ -23,9 +23,6 @@ def verts_from_bbox(bbox, close=False):
     Returns:
         list: verts
 
-    CommandLine:
-        python -m vtool_ibeis.geometry --test-verts_from_bbox
-
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.geometry import *  # NOQA
@@ -66,14 +63,11 @@ def draw_border(img_in, color=(0, 128, 255), thickness=2, out=None):
         thickness (int):
         out (None):
 
-    CommandLine:
-        python -m vtool_ibeis.geometry --test-draw_border --show
-
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.geometry import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> img_in = vt.imread(ut.grab_test_imgpath('carl.jpg'))
+        >>> img_in = vt.imread(ut.grab_test_imgpath('carl'))
         >>> color = (0, 128, 255)
         >>> thickness = 20
         >>> out = None
@@ -121,7 +115,7 @@ def draw_verts(img_in, verts, color=(0, 128, 255), thickness=2, out=None):
         >>> import plottool_ibeis as pt
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img_in = vt.imread(ut.grab_test_imgpath('carl.jpg'))
+        >>> img_in = vt.imread(ut.grab_test_imgpath('carl'))
         >>> verts = ((10, 10), (10, 100), (100, 100), (100, 10))
         >>> color = (0, 128, 255)
         >>> thickness = 2
@@ -143,7 +137,7 @@ def draw_verts(img_in, verts, color=(0, 128, 255), thickness=2, out=None):
         >>> import plottool_ibeis as pt
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img_in = vt.imread(ut.grab_test_imgpath('carl.jpg'))
+        >>> img_in = vt.imread(ut.grab_test_imgpath('carl'))
         >>> verts = ((10, 10), (10, 100), (100, 100), (100, 10))
         >>> color = (0, 128, 255)
         >>> thickness = 2

vtool_ibeis/histogram.py

@@ -975,8 +975,8 @@ def show_ori_image_ondisk():
         >>> pt.show_if_requested()
     """
     #if img_fpath is not None:
-    #    img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
-    #    img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('star.png'))
+    #    img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('astro'))
+    #    img_fpath = ut.get_argval('--fpath', type_=str, default=ut.grab_test_imgpath('astro'))
     #    img = vt.imread(img_fpath)
     #    ori_img_fpath     = ut.get_argval('--fpath-ori', type_=str,
     #    default=ut.augpath(img_fpath, '_ori'))

vtool_ibeis/image.py

@@ -289,12 +289,12 @@ def imread(img_fpath, grayscale=False, orient=False, flags=None,
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> img_fpath = ut.grab_test_imgpath('astro')
         >>> imgBGR1 = imread(img_fpath, grayscale=False)
         >>> imgBGR2 = imread(img_fpath, grayscale=True)
         >>> imgBGR3 = imread(img_fpath, orient=True)
-        >>> assert imgBGR1.shape == (250, 300, 3)
-        >>> assert imgBGR2.shape == (250, 300)
+        >>> assert imgBGR1.shape == (512, 512, 3)
+        >>> assert imgBGR2.shape == (512, 512)
         >>> assert np.all(imgBGR1 == imgBGR3)
         >>> # xdoctest: +REQUIRES(--show)
         >>> import plottool_ibeis as pt
@@ -332,7 +332,7 @@ def imread(img_fpath, grayscale=False, orient=False, flags=None,
         (2736, 3648, 3)
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # xdoctest +SKIP("networking")
         >>> from vtool_ibeis.image import *  # NOQA
         >>> url = 'http://www.sherv.net/cm/emo/funny/2/big-dancing-banana-smiley-emoticon.gif'
         >>> img_fpath = ut.grab_file_url(url)
@@ -540,10 +540,10 @@ def imwrite(img_fpath, imgBGR, fallback=False):
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> import utool as ut
-        >>> img_fpath1 = ut.grab_test_imgpath('zebra.png')
+        >>> img_fpath1 = ut.grab_test_imgpath('astro')
         >>> imgBGR = vt.imread(img_fpath1)
         >>> img_dpath = ub.ensure_app_cache_dir('vtool_ibeis', 'testwrite')
-        >>> img_fpath2 = ut.unixjoin(img_dpath, 'zebra.png')
+        >>> img_fpath2 = ut.unixjoin(img_dpath, 'astro.png')
         >>> fallback = False
         >>> imwrite(img_fpath2, imgBGR, fallback=fallback)
         >>> imgBGR2 = vt.imread(img_fpath2)
@@ -555,7 +555,7 @@ def imwrite(img_fpath, imgBGR, fallback=False):
         if fallback:
             try:
                 imwrite_fallback(img_fpath, imgBGR)
-            except Exception as ex:
+            except Exception:
                 pass
         msg = '[vt.image] ERROR writing: %s' % (img_fpath,)
         ut.printex(ex, msg, keys=['imgBGR.shape'])
@@ -657,11 +657,11 @@ def open_image_size(image_fpath):
 
     Doctest:
         >>> from vtool_ibeis.image import *  # NOQA
-        >>> image_fpath = ut.grab_test_imgpath('patsy.jpg')
+        >>> image_fpath = ut.grab_test_imgpath('carl')
         >>> size = open_image_size(image_fpath)
         >>> result = ('size = %s' % (str(size),))
         >>> print(result)
-        size = (800, 441)
+        size = (328, 448)
 
     Ignore:
         # Confirm that Image.open is a lazy load
@@ -730,7 +730,7 @@ def warpAffine(img, Aff, dsize, assume_float01=True):
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.image 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)
         >>> Aff = vt.rotation_mat3x3(TAU / 8)
         >>> dsize = vt.get_size(img)
@@ -1106,7 +1106,7 @@ def rotate_image_ondisk(img_fpath, theta, out_fpath=None, **kwargs):
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
         >>> # build test data
-        >>> img_fpath = ut.grab_test_imgpath('star.png')
+        >>> img_fpath = ut.grab_test_imgpath('astro')
         >>> theta = TAU * 3 / 8
         >>> # execute function
         >>> out_fpath = None
@@ -1422,9 +1422,9 @@ def convert_colorspace(img, colorspace, src_colorspace='BGR'):
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> img_fpath = ut.grab_test_imgpath('zebra.png')
-        >>> img_fpath = ut.grab_file_url('http://itsnasb.com/wp-content/uploads/2013/03/lisa-frank-logo1.jpg')
-        >>> img_fpath = ut.grab_test_imgpath('carl.jpg')
+        >>> #img_fpath = ut.grab_file_url('http://itsnasb.com/wp-content/uploads/2013/03/lisa-frank-logo1.jpg')
+        >>> #img_fpath = ut.grab_test_imgpath('carl')
+        >>> img_fpath = ut.grab_test_imgpath('pm5644')
         >>> img = vt.imread(img_fpath)
         >>> img_float = vt.rectify_to_float01(img, np.float32)
         >>> colorspace = 'LAB'
@@ -1508,9 +1508,9 @@ def padded_resize(img, target_size=(64, 64), interpolation=None):
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> imgA = vt.imread(ut.grab_test_imgpath('carl.jpg'))
-        >>> imgB = vt.imread(ut.grab_test_imgpath('ada.jpg'))
-        >>> imgC = vt.imread(ut.grab_test_imgpath('carl.jpg'), grayscale=True)
+        >>> imgA = vt.imread(ut.grab_test_imgpath('carl'))
+        >>> imgB = vt.imread(ut.grab_test_imgpath('astro'))
+        >>> imgC = vt.imread(ut.grab_test_imgpath('carl'), grayscale=True)
         >>> #target_size = (64, 64)
         >>> target_size = (1024, 1024)
         >>> img3_list = [padded_resize(img, target_size) for img in [imgA, imgB, imgC]]
@@ -1554,7 +1554,7 @@ def embed_in_square_image(img, target_size, img_origin=(.5, .5),
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.image 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)
         >>> target_size = tuple(np.array(vt.get_size(img)) * 3)
         >>> img_origin = (.5, .5)
@@ -1707,7 +1707,7 @@ def resize_to_maxdims(img, max_dsize=(64, 64),
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.image 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)
         >>> max_dsize = (1024, 1024)
         >>> img2 = resize_to_maxdims(img, max_dsize)
@@ -1737,7 +1737,7 @@ def resize_thumb(img, max_dsize=(64, 64), interpolation=None):
         >>> from vtool_ibeis.image 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)
         >>> max_dsize = (64, 64)
         >>> # execute function
@@ -2008,11 +2008,11 @@ def perlin_noise(size, scale=32.0, rng=np.random):
 def testdata_imglist():
     # build test data
     import vtool_ibeis as vt
-    img1 = vt.imread(ut.grab_test_imgpath('carl.jpg'))
-    img2 = vt.imread(ut.grab_test_imgpath('astro.png'))
-    img3 = vt.imread(ut.grab_test_imgpath('ada.jpg'))
-    img4 = vt.imread(ut.grab_test_imgpath('jeff.png'))
-    img5 = vt.imread(ut.grab_test_imgpath('star.png'))
+    img1 = vt.imread(ut.grab_test_imgpath('carl'))
+    img2 = vt.imread(ut.grab_test_imgpath('astro'))
+    img3 = vt.imread(ut.grab_test_imgpath('stars'))
+    img4 = vt.imread(ut.grab_test_imgpath('pm5644'))
+    img5 = vt.imread(ut.grab_test_imgpath('parrot'))
     img_list = [img1, img2, img3, img4, img5]
     return img_list
 
@@ -2423,9 +2423,9 @@ def ensure_3channel(patch):
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
-        >>> patch1 = vt.imread(ut.grab_test_imgpath('astro.png'))[0:512, 0:500, :]
-        >>> patch2 = vt.imread(ut.grab_test_imgpath('ada.jpg'))[:, :, 0:1]
-        >>> patch3 = vt.imread(ut.grab_test_imgpath('jeff.png'))[0:390, 0:400, 0]
+        >>> patch1 = vt.imread(ut.grab_test_imgpath('astro'))[0:512, 0:500, :]
+        >>> patch2 = vt.imread(ut.grab_test_imgpath('carl'))[:, :, 0:1]
+        >>> patch3 = vt.imread(ut.grab_test_imgpath('paraview'))[0:390, 0:400, 0]
         >>> res1 = ensure_3channel(patch1)
         >>> res2 = ensure_3channel(patch2)
         >>> res3 = ensure_3channel(patch3)
@@ -2489,8 +2489,8 @@ def stack_images(img1, img2, vert=None, modifysize=False, return_sf=False,
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img1 = vt.imread(ut.grab_test_imgpath('carl.jpg'))
-        >>> img2 = vt.imread(ut.grab_test_imgpath('astro.png'))
+        >>> img1 = vt.imread(ut.grab_test_imgpath('carl'))
+        >>> img2 = vt.imread(ut.grab_test_imgpath('astro'))
         >>> vert = True
         >>> modifysize = False
         >>> # execute function
@@ -2645,11 +2645,11 @@ def stack_image_recurse(img_list1, img_list2=None, vert=True, modifysize=False,
         >>> from vtool_ibeis.image import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> # build test data
-        >>> img1 = vt.imread(ut.grab_test_imgpath('carl.jpg'))
-        >>> img2 = vt.imread(ut.grab_test_imgpath('astro.png'))
-        >>> img3 = vt.imread(ut.grab_test_imgpath('ada.jpg'))
-        >>> img4 = vt.imread(ut.grab_test_imgpath('jeff.png'))
-        >>> img5 = vt.imread(ut.grab_test_imgpath('star.png'))
+        >>> img1 = vt.imread(ut.grab_test_imgpath('carl'))
+        >>> img2 = vt.imread(ut.grab_test_imgpath('astro'))
+        >>> img3 = vt.imread(ut.grab_test_imgpath('paraview'))
+        >>> img4 = vt.imread(ut.grab_test_imgpath('lowcontrast'))
+        >>> img5 = vt.imread(ut.grab_test_imgpath('stars'))
         >>> img_list1 = [img1, img2, img3, img4, img5]
         >>> img_list2 = None
         >>> vert = True
@@ -2658,7 +2658,7 @@ def stack_image_recurse(img_list1, img_list2=None, vert=True, modifysize=False,
         >>> # verify results
         >>> # xdoctest: +REQUIRES(--show)
         >>> import plottool_ibeis as pt
-        >>> imshow(imgB)
+        >>> pt.imshow(imgB)
         >>> #wh1 = img1.shape[0:2][::-1]
         >>> #wh2 = img2.shape[0:2][::-1]
         >>> #pt.draw_bbox((0, 0) + wh1, bbox_color=(1, 0, 0))
@@ -2732,8 +2732,8 @@ def filterflags_valid_images(gpaths, valid_formats=None,
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
-        >>> gpaths = [ut.grab_test_imgpath('carl.jpg'),
-        >>>           ut.grab_test_imgpath('astro.png')]
+        >>> gpaths = [ut.grab_test_imgpath('carl'),
+        >>>           ut.grab_test_imgpath('astro')]
         >>> flags = filterflags_valid_images(gpaths)
         >>> assert all(flags)
     """

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

@@ -69,8 +69,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()

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/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)
     """