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

vtool_ibeis/image.py

@@ -1,11 +1,7 @@
-# -*- coding: utf-8 -*-
-# LICENCE
-from __future__ import absolute_import, division, print_function, unicode_literals
 import six
 import os
 from os.path import exists, join  # NOQA
 from os.path import splitext
-from six.moves import zip, map, range  # NOQA
 import numpy as np
 from PIL import Image
 import cv2
@@ -14,6 +10,11 @@ from vtool_ibeis import exif
 import utool as ut
 import ubelt as ub
 
+try:
+    from packaging.version import parse as LooseVersion
+except ImportError:
+    from distutils.version import LooseVersion
+
 
 if cv2 is not None:
 
@@ -43,7 +44,6 @@ if cv2 is not None:
     try:
         IMREAD_COLOR = cv2.IMREAD_COLOR
     except AttributeError:
-        from distutils.version import LooseVersion
         cv2_version = LooseVersion(cv2.__version__)
         print('UNKNOWN cv2_version = {!r}'.format(cv2_version))
         assert cv2_version.version[0] <= 2
@@ -177,11 +177,11 @@ def montage(img_list, dsize, rng=np.random, method='random', return_debug=False)
 
     if use_placement_prob:
         # TODO: place images in places that other images have not been placed yet
-        place_img = np.ones(shape[0:2], dtype=np.float)
+        place_img = np.ones(shape[0:2], dtype=float)
         #place_img[
         #place_img = vt.gaussian_patch(shape[0:2], np.array(shape[0:2]) * .1)
         #place_img = vt.gaussian_patch(shape[0:2], np.array(shape[0:2]) * .3)
-        temp_img = np.ones(shape[0:2], dtype=np.float)
+        temp_img = np.ones(shape[0:2], dtype=float)
         # Enumerate valid 2d locations
         xy_locs_ = np.meshgrid(np.arange(place_img.shape[1]),
                                np.arange(place_img.shape[0]))
@@ -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
@@ -304,7 +304,7 @@ def imread(img_fpath, grayscale=False, orient=False, flags=None,
         >>> ut.show_if_requested()
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.image import *  # NOQA
         >>> img_url = 'http://images.summitpost.org/original/769474.JPG'
         >>> img_fpath = ut.grab_file_url(img_url)
@@ -315,21 +315,24 @@ def imread(img_fpath, grayscale=False, orient=False, flags=None,
         >>> print('imgBGR2.shape = %r' % (imgBGR2.shape,))
         >>> result = str(imgBGR1.shape)
         >>> diff_pxls = imgBGR1 != imgBGR2
+        >>> # Very strange that this fails
         >>> num_diff_pxls = diff_pxls.sum()
         >>> print(result)
         >>> print('num_diff_pxls=%r/%r' % (num_diff_pxls, diff_pxls.size))
         >>> assert num_diff_pxls == 0
         >>> # xdoctest: +REQUIRES(--show)
+        >>> import kwplot
+        >>> kwplot.autompl()
         >>> import plottool_ibeis as pt
         >>> diffMag = np.linalg.norm(imgBGR2 / 255. - imgBGR1 / 255., axis=2)
-        >>> pt.imshow(imgBGR1, pnum=(1, 3, 1))
-        >>> pt.imshow(diffMag / diffMag.max(), pnum=(1, 3, 2))
-        >>> pt.imshow(imgBGR2, pnum=(1, 3, 3))
-        >>> ut.show_if_requested()
+        >>> kwplot.imshow(imgBGR1, pnum=(1, 3, 1))
+        >>> kwplot.imshow(diffMag / diffMag.max(), pnum=(1, 3, 2))
+        >>> kwplot.imshow(imgBGR2, pnum=(1, 3, 3))
+        >>> kwplot.show_if_requested()
         (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)
@@ -537,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)
@@ -552,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'])
@@ -654,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
@@ -727,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)
@@ -1103,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
@@ -1419,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'
@@ -1505,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]]
@@ -1551,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)
@@ -1596,16 +1599,16 @@ def embed_in_square_image(img, target_size, img_origin=(.5, .5),
 
     ## Find start slice in the target image
     target_diff = np.floor(target_origin_abs - img_origin_abs)
-    target_rc_start = np.maximum(target_diff, 0).astype(np.int)
+    target_rc_start = np.maximum(target_diff, 0).astype(int)
 
-    img_rc_start = (-(target_diff - target_rc_start)).astype(np.int)
+    img_rc_start = (-(target_diff - target_rc_start)).astype(int)
     img_clip_rc_low = img_rc - img_rc_start
 
     end_hang = np.maximum((target_rc_start + img_clip_rc_low) - target_rc, 0)
     img_clip_rc = img_clip_rc_low - end_hang
 
-    img_rc_end = (img_rc_start + img_clip_rc).astype(np.int)
-    target_rc_end = (target_rc_start + img_clip_rc).astype(np.int)
+    img_rc_end = (img_rc_start + img_clip_rc).astype(int)
+    target_rc_end = (target_rc_start + img_clip_rc).astype(int)
 
     img_rc_slice = [slice(b, e) for (b, e) in zip(img_rc_start, img_rc_end)]
     target_rc_slice = [slice(b, e) for (b, e) in zip(target_rc_start, target_rc_end)]
@@ -1704,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)
@@ -1734,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
@@ -2005,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
 
@@ -2420,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)
@@ -2486,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
@@ -2642,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
@@ -2655,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))
@@ -2729,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

@@ -1,9 +1,6 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function
-from six.moves import range
 import numpy as np
-import utool as ut
-import ubelt as ub
+import utool as ut  # NOQA
+import ubelt as ub  # NOQA
 import cv2
 
 
@@ -17,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', {}),
@@ -74,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)
 
@@ -102,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
@@ -127,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)
@@ -192,17 +194,16 @@ def grabcut_fn(chipBGR):
     chip_mask = np.where(is_forground, 255, 0).astype('uint8')
     # Crop
     chip_mask = clean_mask(chip_mask)
-    chip_mask = np.array(chip_mask, np.float) / 255.0
+    chip_mask = np.array(chip_mask, float) / 255.0
     # Mask value component of HSV space
     chipHSV = cv2.cvtColor(chipRGB, cv2.COLOR_RGB2HSV)
-    chipHSV = np.array(chipHSV, dtype=np.float) / 255.0
+    chipHSV = np.array(chipHSV, dtype=float) / 255.0
     chipHSV[:, :, 2] *= chip_mask
     chipHSV = np.array(np.round(chipHSV * 255.0), dtype=np.uint8)
     seg_chipBGR = cv2.cvtColor(chipHSV, cv2.COLOR_HSV2BGR)
     return seg_chipBGR
 
 
-
 if __name__ == '__main__':
     """
     CommandLine:

vtool_ibeis/image_shared.py

@@ -1,7 +1,4 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function, unicode_literals
 from PIL import Image
-import cv2
 import utool as ut
 
 
@@ -16,5 +13,5 @@ def print_image_checks(img_fpath):
         _tup = (img_fpath, ut.filesize_str(img_fpath))
         print('[io] Image %r (%s) exists. Is it corrupted?' % _tup)
     else:
-        print('[io] Image %r does not exists ' (img_fpath,))
+        print('[io] Image %r does not exist ' % (img_fpath,))
     return hasimg

vtool_ibeis/inspect_matches.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function
 import utool as ut
 import ubelt as ub
 try:
@@ -71,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/keypoint.py

@@ -129,8 +129,7 @@ Efficiency Notes:
     using np.take is a better idea, but its a bit harder
     to use with multidimensional arrays (nope use axis=x)
 """
-from __future__ import absolute_import, division, print_function
-from six.moves import zip, range, reduce
+from functools import reduce
 import numpy as np
 import numpy.linalg as npl
 from vtool_ibeis import linalg as linalgtool
@@ -524,7 +523,6 @@ def get_invVR_mats3x3(kpts):
         ...    [30, 40, 1, 2, 3, TAU / 4.0],
         ... ])
         >>> invVR_mats3x3 = get_invVR_mats3x3(kpts)
-        >>> # verify results
         >>> result = kpts_repr(invVR_mats3x3)
         >>> print(result)
         array([[[ 1.,  0., 10.],
@@ -537,20 +535,6 @@ def get_invVR_mats3x3(kpts):
     #nKpts = len(kpts)
     invVR_mats2x2 = get_invVR_mats2x2(kpts)
     invVR_mats3x3 = augment_2x2_with_translation(kpts, invVR_mats2x2)
-    # Unpack shape components
-    #_iv11s = invVR_mats2x2.T[0, 0]
-    #_iv12s = invVR_mats2x2.T[1, 0]
-    #_iv21s = invVR_mats2x2.T[0, 1]
-    #_iv22s = invVR_mats2x2.T[1, 1]
-    ## Get translation components
-    #_iv13s, _iv23s = get_xys(kpts)
-    ## Use homogenous coordinates
-    #_zeros = np.zeros(nKpts)
-    #_ones = np.ones(nKpts)
-    #invVR_arrs =  np.array([[_iv11s, _iv12s, _iv13s],
-    #                        [_iv21s, _iv22s, _iv23s],
-    #                        [_zeros, _zeros, _ones]])  # R x C x N
-    #invVR_mats = np.rollaxis(invVR_arrs, 2)  # N x R x C
     return invVR_mats3x3
 
 
@@ -1204,13 +1188,11 @@ def get_invVR_mats_oris(invVR_mats):
         >>> #
 
         nptheta = np.linspace(0, 2 * np.pi, 32, endpoint=False)
-
         mapping = np.arctan(np.tan(nptheta))
         print(ub.repr2(zip(nptheta / (2 * np.pi), nptheta, mapping, nptheta == mapping), precision=3))
         print(ub.repr2(zip(nptheta / (2 * np.pi), nptheta, mapping  % (np.pi * 2), nptheta == mapping % (np.pi * 2)), precision=3))
-
+        >>> # xdoctest: +SKIP
         >>> # NUMPY CHECKS
-
         >>> nptheta_special = [ np.arccos(0), -np.arccos(0), -np.arcsin(0), np.arcsin(0) ]
         >>> nptheta = np.array(np.linspace(0, 2 * np.pi, 64, endpoint=False).tolist() + nptheta_special)
         >>> # Case 1
@@ -1220,6 +1202,7 @@ def get_invVR_mats_oris(invVR_mats):
         >>> case1_result = (-np.arctan(np.tan(-case1_theta)) % TAU)
         >>> case1_theta == case1_result
 
+        >>> # xdoctest: +SKIP
         >>> print(ub.repr2(zip(case1_theta, case1_result, vt.ori_distance(case1_theta, case1_result) ), precision=3))
         >>> #
         >>> # Case 2
@@ -1252,8 +1235,8 @@ def get_invVR_mats_oris(invVR_mats):
 
         # numpy check
 
-
         >>> # LATEX PART
+        >>> # xdoctest: +SKIP
         >>> expr1_repr = vt.sympy_latex_repr(invTVR_held_full)
         >>> print(expr1_repr)
         >>>
@@ -1261,6 +1244,7 @@ def get_invVR_mats_oris(invVR_mats):
         >>> print(expr1_repr)
 
 
+        >>> # xdoctest: +SKIP
         >>> from sympy import Symbol, Q, refine, atan2
         >>> from sympy.assumptions.refine import refine_atan2
         >>> from sympy.abc import x, y
@@ -1271,9 +1255,9 @@ def get_invVR_mats_oris(invVR_mats):
         atan(y/x) - pi
         atan(y/x) + pi
 
+        >>> # xdoctest: +SKIP
         >>> negtheta = sympy.symbols('negtheta', **symkw)
         >>> ori_subs2 = sympy.simplify(sympy.trigsimp(ori_subs))
-
         >>> ori_subs3 = ori_subs2.subs({theta:-negtheta})
         >>> ori_subs4 = sympy.simplify(ori_subs3)
         Out[45]: Mod(-atan2(sin(negtheta)/a, cos(negtheta)/a), 2*pi)
@@ -1298,17 +1282,20 @@ def get_invVR_mats_oris(invVR_mats):
 
 
 
+        >>> # xdoctest: +SKIP
         >>> ori_subs3 = ori_subs2.subs({theta:0})
         >>> ori_subs3 = ori_subs2.subs(dict(theta=0), simultanious=True)
         for sym in ori_subs2.free_symbols:
             print('%r.assumptions0 = %s' % (sym, ub.repr2(sym.assumptions0),))
 
 
+        >>> # xdoctest: +SKIP
         >>> #invTVR = sympy.simplify(RVT_full.inv())
         >>> expr1_repr = vt.sympy_latex_repr(invTVR_full)
         >>> print(expr1_repr)
 
     Sympy:
+        >>> # xdoctest: +SKIP
         >>> import sympy
         >>> import vtool_ibeis as vt
         >>> # First orient a unit circle
@@ -1355,6 +1342,7 @@ def get_invVR_mats_oris(invVR_mats):
 
     Sympy:
         >>> # Show orientation property
+        >>> # xdoctest: +SKIP
         >>> import sympy
         >>> import vtool_ibeis as vt
         >>> # First orient a unit circle
@@ -2169,10 +2157,11 @@ def get_even_point_sample(kpts):
         pyhesaff.tests.test_ellipse
 
     Example:
-        >>> # ENABLE_DOCTEST
+        >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.keypoint import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> kpts = vt.demodata.get_dummy_kpts()[0:2]
+        >>> # not sure why this is failing
         >>> ell_border_pts_list = get_even_point_sample(kpts)
         >>> # xdoctest: +REQUIRES(--show)
         >>> import plottool_ibeis as pt

vtool_ibeis/linalg.py

@@ -33,7 +33,6 @@ TODO: Look at this file
 #     >>> print(xdev.align('\\\\\n'.join(sympy.latex(R).split(r'\\')).replace('{matrix}', '{matrix}\n'), '&')
 
 """
-from __future__ import absolute_import, division, print_function
 import cv2
 import numpy as np
 import numpy.linalg as npl

vtool_ibeis/matching.py

@@ -1,10 +1,8 @@
-# -*- coding: utf-8 -*-
 """
     vt
     python -m utool.util_inspect check_module_usage --pat="matching.py"
 
 """
-from __future__ import absolute_import, division, print_function
 from vtool_ibeis import _rhomb_dist
 import six
 import warnings
@@ -104,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:
@@ -143,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)
@@ -164,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)
@@ -455,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))
 
@@ -576,7 +578,7 @@ class PairwiseMatch(ub.NiceRepr):
             ori_err = np.full(n_fm, fill_value=np.inf)
             agg_errors = (xy_err, scale_err, ori_err)
 
-            agg_inlier_flags = np.zeros(n_fm, dtype=np.bool)
+            agg_inlier_flags = np.zeros(n_fm, dtype=bool)
 
             agg_H_12 = None
             prev_best = 50
@@ -1449,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)
@@ -1636,7 +1638,7 @@ def asymmetric_correspondence(annot1, annot2, K, Knorm, checks, allow_shrink=Tru
 
     fx2_to_fx1, fx2_to_dist = normalized_nearest_neighbors(
         annot1['flann'], annot2['vecs'], num_neighbors, checks)
-    fx2_to_flags = np.ones((len(fx2_to_fx1), K), dtype=np.bool)
+    fx2_to_flags = np.ones((len(fx2_to_fx1), K), dtype=bool)
     # Assign correspondences
     assigntup = assign_unconstrained_matches(fx2_to_fx1, fx2_to_dist, K,
                                              Knorm, fx2_to_flags)
@@ -1706,8 +1708,8 @@ def assign_symmetric_matches(fx2_to_fx1, fx2_to_dist, fx1_to_fx2, fx1_to_dist,
     fx12.columns.name = 'K'
     fx12.index.name = 'fx2'
 
-    fx12 = fx12.T[0:K].T.astype(np.float)
-    fx21 = fx21.T[0:K].T.astype(np.float)
+    fx12 = fx12.T[0:K].T.astype(float)
+    fx21 = fx21.T[0:K].T.astype(float)
 
     fx12.values[~fx1_to_flags] = np.nan
     fx21.values[~fx2_to_flags] = np.nan
@@ -1867,7 +1869,7 @@ def assign_unconstrained_matches(fx2_to_fx1, fx2_to_dist, K, Knorm=None,
         # make everything valid
         flat_validx = np.arange(len(fx2_to_fx1) * K, dtype=index_dtype)
     else:
-        #fx2_to_flags = np.ones((len(fx2_to_fx1), K), dtype=np.bool)
+        #fx2_to_flags = np.ones((len(fx2_to_fx1), K), dtype=bool)
         flat_validx = np.flatnonzero(fx2_to_flags)
 
     match_fx2  = np.floor_divide(flat_validx, K, dtype=index_dtype)
@@ -1912,7 +1914,7 @@ def flag_sym_slow(fx1_to_fx2, fx2_to_fx1, K):
         fx2_m = fx1_to_fx2[fx1, :K]
         # Find img2 features that have fx1 in their top K
         reverse_m = fx2_to_fx1[fx2_m, :K]
-        is_recip = (reverse_m == fx1).sum(axis=1).astype(np.bool)
+        is_recip = (reverse_m == fx1).sum(axis=1).astype(bool)
         fx1_to_flags.append(is_recip)
     fx1_to_flags = np.array(fx1_to_flags)
     return fx1_to_flags