vtool-ibeis 2.2.1__py3-none-any.whl → 2.3.1__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.1'
 __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/clustering2.py

@@ -282,7 +282,7 @@ def find_duplicate_items(item_arr):
         >>> np.random.seed(0)
         >>> item_arr = np.random.randint(100, size=30)
         >>> duplicate_items = find_duplicate_items(item_arr)
-        >>> assert duplicate_items == list(six.iterkeys(ut.find_duplicate_items(item_arr)))
+        >>> assert duplicate_items == list(ut.find_duplicate_items(item_arr).keys())
         >>> result = str(duplicate_items)
         >>> print(result)
         [9, 67, 87, 88]

vtool_ibeis/confusion.py

@@ -382,12 +382,7 @@ class ConfusionMetrics(ub.NiceRepr):
         # sklearn has much faster implementation
         # n_fp - count the number of false positives with score >= threshold[i]
         # n_tp - count the number of true positives with score >= threshold[i]
-        try:
-            from sklearn.metrics._ranking import _binary_clf_curve
-        except ImportError:
-            from sklearn.metrics.ranking import _binary_clf_curve
-
-        n_fp, n_tp, thresholds = _binary_clf_curve(
+        n_fp, n_tp, thresholds = _binary_counts_at_thresholds(
             labels, scores, pos_label=1)
 
         n_samples = len(labels)
@@ -1160,6 +1155,58 @@ def draw_precision_recall_curve(recall_domain, p_interp, title_pref=None,
     #fig.show()
 
 
+def _binary_clf_curve_local(y_true, y_score, pos_label=1):
+    """
+    Minimal replacement for sklearn.metrics._ranking._binary_clf_curve (unweighted).
+    Returns: fps, tps, thresholds
+    """
+    import numpy as np
+
+    y_true = np.asarray(y_true)
+    y_score = np.asarray(y_score)
+
+    y_true = (y_true == pos_label)
+
+    # sort scores descending
+    desc = np.argsort(y_score, kind="mergesort")[::-1]
+    y_score = y_score[desc]
+    y_true = y_true[desc]
+
+    # indices where score changes
+    distinct = np.where(np.diff(y_score))[0]
+    threshold_idxs = np.r_[distinct, y_true.size - 1]
+
+    tps = np.cumsum(y_true)[threshold_idxs]
+    fps = (threshold_idxs + 1) - tps
+    thresholds = y_score[threshold_idxs]
+    return fps, tps, thresholds
+
+
+def _binary_counts_at_thresholds(labels, scores, pos_label=1):
+    """
+    Returns fps, tps, thresholds (like old _binary_clf_curve) using public API when available.
+    """
+    try:
+        from sklearn.metrics._ranking import _binary_clf_curve
+    except ImportError:
+        try:
+            from sklearn.metrics.ranking import _binary_clf_curve
+        except ImportError:
+            _binary_clf_curve = None
+
+    if _binary_clf_curve is not None:
+        n_fp, n_tp, thresholds = _binary_clf_curve(
+            labels, scores, pos_label=1)
+    else:
+        # scikit-learn >= 1.8
+        n_fp, n_tp, thresholds = _binary_clf_curve_local(labels, scores, pos_label)
+        # from sklearn.metrics import confusion_matrix_at_thresholds
+        # n_tp, n_fp, fns, tps, thresholds = confusion_matrix_at_thresholds(
+        #     labels, scores, pos_label=pos_label
+        # )
+    return n_fp, n_tp, thresholds
+
+
 if __name__ == '__main__':
     """
     CommandLine:

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/distance.py

@@ -732,6 +732,25 @@ def safe_pdist(arr, *args, **kwargs):
 
     SeeAlso:
         scipy.spatial.distance.pdist
+
+    Example:
+        >>> # xdoctest: +REQUIRES(module:vtool)
+        >>> import vtool_ibeis as vt
+        >>> import numpy as np
+        >>> arr = np.array([1, 2, 3, 4, 5])
+        >>> result = vt.safe_pdist(arr)
+        >>> assert result.shape == (10,)
+        >>> # metric needs to return a scalar, even if the inputs are vectors
+        >>> # Test the use-cases in ibeis
+        >>> result = vt.safe_pdist(arr, metric=lambda x, y: abs(x - y).item())
+        >>> assert result.shape == (10,)
+        >>> result = vt.safe_pdist(arr, metric=lambda *a: ut.unixtime_hourdiff(*a)[0])
+        >>> assert result.shape == (10,)
+        >>> result = vt.safe_pdist(arr, metric=lambda *a: vt.ori_distance(*a)[0])
+        >>> assert result.shape == (10,)
+        >>> latlon_arr = np.array([(40, 20), (20, 30), (-40, 20)])
+        >>> km_dists = ut.safe_pdist(latlon_arr, metric=vt.haversine)
+        >>> assert km_dists.shape == (3,)
     """
     if arr is None or len(arr) < 2:
         return None

vtool_ibeis/exif.py

@@ -244,7 +244,7 @@ def get_lat_lon(exif_dict, default=(-1, -1)):
         python -m vtool_ibeis.exif --test-get_lat_lon
 
     Example:
-        >>> # DISABLE_DOCTEST
+        >>> # xdoctest: +SKIP("bad url")
         >>> from vtool_ibeis.exif import *  # NOQA
         >>> import numpy as np
         >>> image_fpath = ut.grab_file_url('http://images.summitpost.org/original/769474.JPG')
@@ -294,7 +294,7 @@ def get_orientation(exif_dict, default=0, on_error='warn'):
         python -m vtool_ibeis.exif --test-get_orientation
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +SKIP("bad url")
         >>> from vtool_ibeis.exif import *  # NOQA
         >>> from os.path import join
         >>> import numpy as np
@@ -334,7 +334,7 @@ def get_orientation_str(exif_dict, **kwargs):
         python -m vtool_ibeis.exif --test-get_orientation_str
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +SKIP("bad url")
         >>> from vtool_ibeis.exif import *  # NOQA
         >>> from os.path import join
         >>> import numpy as np
@@ -360,7 +360,7 @@ def get_unixtime(exif_dict, default=-1):
     TODO: Exif.Image.TimeZoneOffset
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +SKIP("bad url")
         >>> from vtool_ibeis.exif import *  # NOQA
         >>> image_fpath = ut.grab_file_url('http://images.summitpost.org/original/769474.JPG')
         >>> pil_img = Image.open(image_fpath)

vtool_ibeis/features.py

@@ -1,6 +1,5 @@
 import utool as ut
 import ubelt as ub
-import six
 
 
 def extract_feature_from_patch(patch):
@@ -41,7 +40,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
@@ -69,7 +68,7 @@ def extract_features(img_or_fpath, feat_type='hesaff+sift', **kwargs):
         # hacky
         from ibeis_cnn import _plugin
         (kpts, sift) = pyhesaff.detect_feats2(img_or_fpath, **kwargs)
-        if isinstance(img_or_fpath, six.string_types):
+        if isinstance(img_or_fpath, str):
             import vtool_ibeis as vt
             img_or_fpath = vt.imread(img_or_fpath)
         vecs_list = _plugin.extract_siam128_vecs([img_or_fpath], [kpts])
@@ -109,8 +108,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 +249,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

@@ -20,18 +20,21 @@ def argsubmax(ydata, xdata=None):
         >>> xdata = [00, 10, 20,  30, 40]
         >>> result1 = argsubmax(ydata, xdata=None)
         >>> result2 = argsubmax(ydata, xdata=xdata)
-        >>> result = ub.repr2([result1, result2], precision=4, nl=1, nobr=True)
-        >>> print(result)
-        2.1667, 2.0208,
-        21.6667, 2.0208,
+        >>> import ubelt as ub
+        >>> print(f'result1 = {ub.urepr(result1, nl=0, precision=3)}')
+        >>> print(f'result2 = {ub.urepr(result2, nl=0, precision=3)}')
+        result1 = (2.167, 2.021)
+        result2 = (21.667, 2.021)
 
     Example:
         >>> from vtool_ibeis.histogram import *  # NOQA
         >>> hist_ = np.array([0, 1, 2, 3, 4])
         >>> centers = None
         >>> maxima_thresh=None
-        >>> argsubmax(hist_)
-        (4.0, 4.0)
+        >>> result = argsubmax(hist_)
+        >>> import ubelt as ub
+        >>> print(f'result = {ub.urepr(result, nl=0)}')
+        result = (4.0, 4.0)
     """
     if len(ydata) == 0:
         raise IndexError('zero length array')
@@ -975,8 +978,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

@@ -1,4 +1,3 @@
-import six
 import os
 from os.path import exists, join  # NOQA
 from os.path import splitext
@@ -82,7 +81,7 @@ def _rectify_border_mode(border_mode, default=cv2.BORDER_CONSTANT):
     """ Converts argument to cv2 style """
     if border_mode is None:
         return default
-    elif isinstance(border_mode, six.text_type):
+    elif isinstance(border_mode, str):
         return CV2_BORDER_TYPES[border_mode]
     else:
         return border_mode
@@ -102,7 +101,7 @@ def _rectify_interpolation(interp, default=cv2.INTER_LANCZOS4):
     """
     if interp is None:
         return default
-    elif isinstance(interp, six.text_type):
+    elif isinstance(interp, str):
         try:
             return CV2_INTERPOLATION_TYPES[interp]
         except KeyError:
@@ -289,12 +288,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 +331,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)
@@ -441,7 +440,7 @@ def imread_remote_s3(img_fpath, **kwargs):
 
 
 def imread_remote_url(img_url, **kwargs):
-    from six.moves import urllib
+    import urllib
     import io
     print("USE PIL REMOTE")
     addinfourl = urllib.request.urlopen(img_url)
@@ -470,7 +469,10 @@ def _imread_bytesio(image_stream, use_pil=False, flags=None, **kwargs):
         if flags is None:
             grayscale = kwargs.get('grayscale', False)
             flags = cv2.IMREAD_GRAYSCALE if grayscale else IMREAD_COLOR
-        nparr = np.fromstring(image_stream.getvalue(), np.uint8)
+        try:
+            nparr = np.fromstring(image_stream.getvalue(), np.uint8)
+        except Exception:
+            nparr = np.frombuffer(image_stream.getvalue(), np.uint8)
         imgBGR = cv2.imdecode(nparr, flags=flags)  # cv2.IMREAD_COLOR in OpenCV 3.1
     return imgBGR
 
@@ -540,10 +542,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 +557,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 +659,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 +732,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 +1108,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 +1424,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 +1510,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 +1556,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 +1709,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 +1739,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 +2010,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
 
@@ -2199,7 +2201,7 @@ def combine_offset_lists(offsets_list, sfs_list, offset_tups, sf_tups):
     """ Helper for stacking """
     # combine the offsets
     import operator
-    from six.moves import reduce
+    from functools import reduce
 
     assert len(offsets_list) == len(offset_tups)
     assert len(sfs_list) == len(sf_tups)
@@ -2423,9 +2425,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 +2491,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 +2647,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 +2660,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 +2734,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)
     """