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

vtool_ibeis/nearest_neighbors.py

@@ -3,7 +3,6 @@ Wrapper around flann (with caching)
 
 python -c "import vtool_ibeis, doctest; print(doctest.testmod(vtool_ibeis.nearest_neighbors))"
 """
-from __future__ import absolute_import, division, print_function
 from os.path import exists, normpath, join
 import utool as ut
 import ubelt as ub
@@ -39,8 +38,8 @@ class AnnoyWrapper(object):
     def nn_index(self, qvecs, num_neighbs, checks=None):
         if checks is None:
             checks = self.params['checks']
-        idxs = np.empty((len(qvecs), num_neighbs), dtype=np.int)
-        dists = np.empty((len(qvecs), num_neighbs), dtype=np.float)
+        idxs = np.empty((len(qvecs), num_neighbs), dtype=int)
+        dists = np.empty((len(qvecs), num_neighbs), dtype=float)
         for i, qvec in enumerate(qvecs):
             idxs[i], dists[i] = self.ann.get_nns_by_vector(
                 qvec, n=num_neighbs, search_k=checks, include_distances=True)
@@ -110,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)
@@ -176,6 +177,7 @@ def ann_flann_once(dpts, qpts, num_neighbors, flann_params={}):
 
     Example0:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> np.random.seed(1)
         >>> dpts = np.random.randint(0, 255, (5, 128)).astype(np.uint8)
@@ -196,6 +198,7 @@ def ann_flann_once(dpts, qpts, num_neighbors, flann_params={}):
         >>> # ENABLE_DOCTEST
         >>> # Test upper bounds on sift descriptors
         >>> # SeeAlso distance.understanding_pseudomax_props
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> import vtool_ibeis as vt
         >>> import numpy as np
@@ -301,6 +304,7 @@ def get_flann_cfgstr(dpts, flann_params, cfgstr='', use_params_hash=True,
 
     Example:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> rng = np.random.RandomState(1)
         >>> dpts = rng.randint(0, 255, (10, 128)).astype(np.uint8)
@@ -404,6 +408,7 @@ def flann_augment(dpts, new_dpts, cache_dir, cfgstr, new_cfgstr, flann_params,
     """
     Example:
         >>> # DISABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> import vtool_ibeis.demodata as demodata  # NOQA
         >>> dpts = demodata.get_dummy_dpts(ut.get_nth_prime(10))
@@ -452,6 +457,7 @@ def get_flann_params(algorithm='kdtree', **kwargs):
 
     Example:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> algorithm = ut.get_argval('--algo', default='kdtree')
         >>> flann_params = get_flann_params(algorithm)
@@ -660,6 +666,7 @@ def flann_index_time_experiment():
     Example:
         >>> # SLOW_DOCTEST
         >>> # xdoctest: +SKIP
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> result = flann_index_time_experiment()
         >>> print(result)
@@ -755,6 +762,7 @@ def invertible_stack(vecs_list, label_list):
 
     Example:
         >>> # DISABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyflann_ibeis)
         >>> from vtool_ibeis.nearest_neighbors import *  # NOQA
         >>> DESC_TYPE = np.uint8
         >>> label_list  = [1, 2, 3, 4, 5]

vtool_ibeis/numpy_utils.py

@@ -1,13 +1,9 @@
-# -*- coding: utf-8 -*
 """
 These functions might be PR quality for numpy.
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
 import numpy as np
-import utool as ut
-import ubelt as ub
-from six import next
-from six.moves import zip, range
+import utool as ut  # NOQA
+import ubelt as ub  # NOQA
 
 
 def atleast_nd(arr, n, tofront=False):
@@ -121,7 +117,7 @@ def fromiter_nd(iter_, shape, dtype):
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.numpy_utils import *  # NOQA
-        >>> dtype = np.float
+        >>> dtype = float
         >>> total = 11
         >>> rng = np.random.RandomState(0)
         >>> iter_ = (rng.rand(5, 7, 3) for _ in range(total))
@@ -132,7 +128,7 @@ def fromiter_nd(iter_, shape, dtype):
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.numpy_utils import *  # NOQA
-        >>> dtype = np.int
+        >>> dtype = int
         >>> qfxs = np.array([1, 2, 3])
         >>> dfxs = np.array([4, 5, 6])
         >>> iter_ = (np.array(x) for x in ut.product(qfxs, dfxs))
@@ -148,7 +144,7 @@ def fromiter_nd(iter_, shape, dtype):
         >>> sigma = 500
         >>> n_data = 1000
         >>> rng = np.random.RandomState(42)
-        >>> n_feat_list = np.clip(rng.randn(n_data) * sigma + mu, 0, np.inf).astype(np.int)
+        >>> n_feat_list = np.clip(rng.randn(n_data) * sigma + mu, 0, np.inf).astype(int)
         >>> # Make a large list of vectors of various sizes
         >>> print('Making random vectors')
         >>> vecs_list = [(rng.rand(num, feat_dim) * 255).astype(dtype) for num in n_feat_list]
@@ -229,7 +225,7 @@ def index_to_boolmask(index_list, maxval=None, isflat=True):
     #assert index_list.min() >= 0
     if maxval is None:
         maxval = index_list.max()
-    mask = np.zeros(maxval, dtype=np.bool)
+    mask = np.zeros(maxval, dtype=bool)
     if not isflat:
         # assumes non-flat
         mask.__setitem__(tuple(index_list.T), True)

vtool_ibeis/other.py

@@ -1,11 +1,7 @@
-# -*- coding: utf-8 -*
-from __future__ import absolute_import, division, print_function, unicode_literals
 import numpy as np
 import utool as ut
 import ubelt as ub
 import functools  # NOQA
-from six import next
-from six.moves import zip, range
 
 
 def safe_vstack(tup, default_shape=(0,), default_dtype=float):
@@ -456,7 +452,7 @@ def compute_unique_data_ids_(hashable_rows, iddict_=None):
     for row in hashable_rows:
         if row not in iddict_:
             iddict_[row] = len(iddict_)
-    dataid_list = ut.dict_take(iddict_, hashable_rows)
+    dataid_list = list(ub.take(iddict_, hashable_rows))
     return dataid_list
 
 
@@ -1143,8 +1139,8 @@ def flag_intersection(arr1, arr2):
     """
     import vtool_ibeis as vt
     if arr1.size == 0 or arr2.size == 0:
-        flags = np.full(arr1.shape[0], False, dtype=np.bool)
-        #return np.empty((0,), dtype=np.bool)
+        flags = np.full(arr1.shape[0], False, dtype=bool)
+        #return np.empty((0,), dtype=bool)
     else:
         # flags = np.logical_or.reduce([arr1 == row for row in arr2]).T[0]
         flags = vt.iter_reduce_ufunc(np.logical_or, (arr1 == row_ for row_ in arr2)).ravel()
@@ -1357,6 +1353,7 @@ def get_uncovered_mask(covered_array, covering_array):
         >>> flags = get_uncovered_mask(covered_array, covering_array)
         >>> result = ub.repr2(flags, with_dtype=True)
         >>> print(result)
+
         np.array([[ True, False,  True],
                   [False, False,  True],
                   [ True,  True,  True]], dtype=bool)
@@ -1372,13 +1369,13 @@ def get_uncovered_mask(covered_array, covering_array):
     """
     import vtool_ibeis as vt
     if len(covering_array) == 0:
-        return np.ones(np.shape(covered_array), dtype=np.bool)
+        return np.ones(np.shape(covered_array), dtype=bool)
     else:
         flags_iter = (np.not_equal(covered_array, item) for item in covering_array)
         mask_array = vt.iter_reduce_ufunc(np.logical_and, flags_iter)
         return mask_array
     #if len(covering_array) == 0:
-    #    return np.ones(np.shape(covered_array), dtype=np.bool)
+    #    return np.ones(np.shape(covered_array), dtype=bool)
     #else:
     #    flags_list = (np.not_equal(covered_array, item) for item in covering_array)
     #    mask_array = and_lists(*flags_list)
@@ -1387,7 +1384,7 @@ def get_uncovered_mask(covered_array, covering_array):
 
 #def get_uncovered_mask2(covered_array, covering_array):
 #    if len(covering_array) == 0:
-#        return np.ones(np.shape(covered_array), dtype=np.bool)
+#        return np.ones(np.shape(covered_array), dtype=bool)
 #    else:
 #        flags_iter = (np.not_equal(covered_array, item) for item in covering_array)
 #        mask_array = vt.iter_reduce_ufunc(np.logical_and, flags_iter)
@@ -2419,7 +2416,7 @@ def fromiter_nd(iter_, shape, dtype):
     Example:
         >>> # ENABLE_DOCTEST
         >>> from vtool_ibeis.other import *  # NOQA
-        >>> dtype = np.int
+        >>> dtype = int
         >>> qfxs = np.array([1, 2, 3])
         >>> dfxs = np.array([4, 5, 6])
         >>> iter_ = (np.array(x) for x in ut.product(qfxs, dfxs))
@@ -2496,7 +2493,7 @@ def take_col_per_row(arr, colx_list):
         num_cols = 4
 
         arr = np.arange(10 * 4).reshape(10, 4)
-        colx_list = (np.random.rand(10) * 4).astype(np.int)
+        colx_list = (np.random.rand(10) * 4).astype(int)
 
         %timeit np.array([row[cx] for (row, cx) in zip(arr, colx_list)])
         %timeit arr.ravel().take(np.ravel_multi_index((np.arange(len(colx_list)), colx_list), arr.shape))

vtool_ibeis/patch.py

@@ -1,8 +1,3 @@
-# -*- coding: utf-8 -*-
-# LICENCE
-from __future__ import absolute_import, division, print_function, unicode_literals
-import six  # NOQA
-from six.moves import zip
 import numpy as np
 from vtool_ibeis import histogram as htool
 from vtool_ibeis import keypoint as ktool
@@ -575,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)
@@ -732,7 +727,7 @@ def intern_warp_single_patch(img, x, y, ori, V,
     X = ltool.translation_mat3x3(half_patch_size, half_patch_size)  # Translate back to patch-image coordinates
     M = X.dot(S).dot(R).dot(V).dot(T)
     # Prepare to warp
-    dsize = np.ceil([patch_size, patch_size]).astype(np.int)
+    dsize = np.ceil([patch_size, patch_size]).astype(int)
     # Warp
     #warped_patch = gtool.warpAffine(img, M, dsize)
     warped_patch = cv2.warpAffine(img, M[0:2], tuple(dsize), **cv2_warp_kwargs)
@@ -781,7 +776,7 @@ def patch_gaussian_weighted_average_intensities(probchip, kpts_):
     import vtool_ibeis as vt
     patch_size = 41
     M_iter = vt.generate_to_patch_transforms(kpts_, patch_size)
-    dsize = np.ceil([patch_size, patch_size]).astype(np.int)
+    dsize = np.ceil([patch_size, patch_size]).astype(int)
     # Preallocate patch
     patch = np.empty(dsize[::-1], dtype=np.uint8)
     weighted_patch = np.empty(dsize[::-1], dtype=np.float64)
@@ -1070,19 +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
-    from six.moves import input
-    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:
@@ -1091,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 = []
@@ -1127,12 +1109,6 @@ def draw_kp_ori_steps():
         internal_tup = ut.exec_func_src(find_patch_dominant_orientations, globals_, locals_, key_list=keys, update=True)
         submax_ori_offsets = globals_['submax_ori_offsets']
         new_oris = (old_ori + (submax_ori_offsets - ktool.GRAVITY_THETA)) % TAU
-        # sourcecode = ut.get_func_sourcecode(find_patch_dominant_orientations, stripdef=True, stripret=True)
-        # six.exec_(sourcecode, globals_, locals_)
-        # submax_ori_offsets = locals_['submax_ori_offsets']
-        # new_oris = (old_ori + (submax_ori_offsets - ktool.GRAVITY_THETA)) % TAU
-        # keys = 'patch, gradx, grady, gmag, gori, hist, centers, gori_weights'.split(', ')
-        # internal_tup = ut.dict_take(locals_, keys)
         return new_oris, internal_tup
         # </HACKISH>
 

vtool_ibeis/quality_classifier.py

@@ -4,7 +4,6 @@ References:
     % Single-image noise level estimation for blind denoising.
     % http://www.ok.ctrl.titech.ac.jp/res/NLE/TIP2013-noise-level-estimation06607209.pdfhttp://www.ok.ctrl.titech.ac.jp/res/NLE/TIP2013-noise-level-estimation06607209.pdf
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
 import utool as ut
 import ubelt as ub
 import numpy as np
@@ -20,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)
@@ -105,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

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, division, print_function, unicode_literals
 import numpy as np
 import utool as ut
 import ubelt as ub
@@ -813,7 +811,7 @@ def partition_scores(X, y, attrs=None):
         >>> from vtool_ibeis.score_normalization import *  # NOQA
         >>> X = np.array([5, 6, 6, 7, 1, 2, 2])
         >>> attrs = {'qaid': np.array([21, 24, 25, 26, 11, 14, 15])}
-        >>> y = np.array([1, 1, 1, 1, 0, 0, 0], dtype=np.bool)
+        >>> y = np.array([1, 1, 1, 1, 0, 0, 0], dtype=bool)
         >>> tup = partition_scores(X, y, attrs)
         >>> resdict = ut.odict(zip(
         >>>     ['tp_scores', 'tn_scores', 'part_attrs'], tup))
@@ -827,7 +825,6 @@ def partition_scores(X, y, attrs=None):
             False: {'qaid': np.array([11, 14, 15])},
             True: {'qaid': np.array([21, 24, 25, 26])},
         },
-
     """
     import vtool_ibeis as vt
     import operator
@@ -879,7 +876,7 @@ def flatten_scores(tp_scores, tn_scores, part_attrs=None):
         >>> tup = flatten_scores(
         ... tp_scores, tn_scores, part_attrs)
         >>> (X, y, attrs) = tup
-        >>> y = y.astype(np.int)
+        >>> y = y.astype(int)
         >>> resdict = ut.odict(zip(['X', 'y', 'attrs'], [X, y, attrs]))
         >>> result = ub.repr2(resdict, nobraces=True, with_dtype=False,
         >>>                      explicit=1, nl=1)
@@ -890,7 +887,7 @@ def flatten_scores(tp_scores, tn_scores, part_attrs=None):
         attrs={'qaid': np.array([21, 24, 25, 26, 11, 14, 15])},
     """
     scores = np.hstack([tp_scores, tn_scores])
-    labels = np.zeros(scores.size, dtype=np.bool)
+    labels = np.zeros(scores.size, dtype=bool)
     labels[0:len(tp_scores)] = True
     if part_attrs is None:
         return scores, labels

vtool_ibeis/segmentation.py

@@ -1,5 +1,3 @@
-from __future__ import absolute_import, division, print_function
-from six.moves import range, zip  # NOQA
 import numpy as np
 import cv2
 import utool as ut
@@ -87,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)
@@ -142,7 +140,7 @@ def demo_grabcut(bgr_img):
     with ut.Timer('grabcut'):
         post_mask = grabcut(bgr_img, prior_mask)
     if post_mask.dtype == np.uint8:
-        post_mask = post_mask.astype(np.float) / 255.0
+        post_mask = post_mask.astype(float) / 255.0
     seg_chip = mask_colored_img(bgr_img, post_mask, 'bgr')
     print('finished running grabcut')
     pt.imshow(post_mask * 255, pnum=(1, 2, 1))
@@ -188,12 +186,12 @@ from_hsv_flags = {
 
 def mask_colored_img(img_rgb, mask, encoding='bgr'):
     if mask.dtype == np.uint8:
-        mask = mask.astype(np.float) / 255.0
+        mask = mask.astype(float) / 255.0
     into_hsv_flag = into_hsv_flags[encoding]
     from_hsv_flag = from_hsv_flags[encoding]
     # Mask out value component
     img_hsv = cv2.cvtColor(img_rgb, into_hsv_flag)
-    img_hsv = np.array(img_hsv, dtype=np.float) / 255.0
+    img_hsv = np.array(img_hsv, dtype=float) / 255.0
     VAL_INDEX = 2
     img_hsv[:, :, VAL_INDEX] *= mask
     img_hsv = np.array(np.round(img_hsv * 255.0), dtype=np.uint8)
@@ -228,7 +226,7 @@ def grabcut2(rgb_chip):
     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
     seg_chip = mask_colored_img(rgb_chip, chip_mask, 'rgb')
     return seg_chip
@@ -266,10 +264,10 @@ def segment(img_fpath, bbox_, new_size=None):
     chip      = img_resz[y1:y2, x1:x2]
     chip_mask = img_mask[y1:y2, x1:x2]
     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 the value of HSV
     chip_hsv = cv2.cvtColor(chip, cv2.COLOR_RGB2HSV)
-    chip_hsv = np.array(chip_hsv, dtype=np.float) / 255.0
+    chip_hsv = np.array(chip_hsv, dtype=float) / 255.0
     chip_hsv[:, :, 2] *= chip_mask
     chip_hsv = np.array(np.round(chip_hsv * 255.0), dtype=np.uint8)
     seg_chip = cv2.cvtColor(chip_hsv, cv2.COLOR_HSV2RGB)

vtool_ibeis/spatial_verification.py

@@ -267,10 +267,10 @@ def compute_affine(xy1_man, xy2_man):
 
     Example1:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
         >>> import vtool_ibeis.demodata as demodata
         >>> import vtool_ibeis.keypoint as ktool
-        >>> import plottool_ibeis as pt
         >>> xy1_man, xy2_man, rchip1, rchip2, T1, T2 = testdata_matching_affine_inliers_normalized()
         >>> A_prime = compute_affine(xy1_man, xy2_man)
         >>> A = npl.solve(T2, A_prime).dot(T1)
@@ -278,6 +278,7 @@ def compute_affine(xy1_man, xy2_man):
         >>> result = np.array_str(A, precision=2)
         >>> print(result)
         >>> # xdoctest: +REQUIRES(--show)
+        >>> import plottool_ibeis as pt
         >>> rchip2_blendA = pt.draw_sv.get_blended_chip(rchip1, rchip2, A)
         >>> pt.imshow(rchip2_blendA)
         >>> ut.show_if_requested()
@@ -318,6 +319,7 @@ def compute_homog(xy1_mn, xy2_mn):
 
     Example:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
         >>> import vtool_ibeis.keypoint as ktool
         >>> import vtool_ibeis.demodata as demodata
@@ -334,6 +336,7 @@ def compute_homog(xy1_mn, xy2_mn):
 
     Example1:
         >>> # ENABLE_DOCTEST
+        >>> # xdoctest: +REQUIRES(module:pyhesaff)
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
         >>> import vtool_ibeis.keypoint as ktool
         >>> xy1_man, xy2_man, rchip1, rchip2, T1, T2 = testdata_matching_affine_inliers_normalized()
@@ -371,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)
@@ -461,7 +464,7 @@ def _test_hypothesis_inliers(Aff, invVR1s_m, xy2_m, det2_m, ori2_m,
     ori_inliers_flag   = np.less(ori_err, ori_thresh)
     #np.logical_and(xy_inliers_flag, scale_inliers_flag)
     # TODO Add uniqueness of matches constraint
-    #hypo_inliers_flag = np.empty(xy_inliers_flag.size, dtype=np.bool)
+    #hypo_inliers_flag = np.empty(xy_inliers_flag.size, dtype=bool)
     hypo_inliers_flag = xy_inliers_flag  # Try to re-use memory
     np.logical_and(hypo_inliers_flag, ori_inliers_flag, out=hypo_inliers_flag)
     np.logical_and(hypo_inliers_flag, scale_inliers_flag, out=hypo_inliers_flag)
@@ -694,7 +697,6 @@ def test_homog_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh,
     Example0:
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
-        >>> import plottool_ibeis as pt
         >>> kpts1, kpts2, fm, aff_inliers, rchip1, rchip2, xy_thresh_sqrd = testdata_matching_affine_inliers()
         >>> H = estimate_refined_transform(kpts1, kpts2, fm, aff_inliers)
         >>> scale_thresh, ori_thresh = 2.0, 1.57
@@ -702,13 +704,13 @@ def test_homog_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh,
         >>> homog_tup1 = test_homog_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh, ori_thresh, full_homog_checks)
         >>> homog_tup = (homog_tup1[0], homog_tup1[2])
         >>> # xdoctest: +REQUIRES(--show)
+        >>> import plottool_ibeis as pt
         >>> pt.draw_sv.show_sv(rchip1, rchip2, kpts1, kpts2, fm, homog_tup=homog_tup)
         >>> ut.show_if_requested()
 
     Example1:
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
-        >>> import plottool_ibeis as pt
         >>> kpts1, kpts2, fm_, aff_inliers, rchip1, rchip2, xy_thresh_sqrd = testdata_matching_affine_inliers()
         >>> H = estimate_refined_transform(kpts1, kpts2, fm_, aff_inliers)
         >>> scale_thresh, ori_thresh = 2.0, 1.57
@@ -731,6 +733,7 @@ def test_homog_errors(H, kpts1, kpts2, fm, xy_thresh_sqrd, scale_thresh,
         ...     'kpts1_m, kpts2_m, off_xy1_m, off_xy1_mt, dxy1_m, dxy1_mt, xy2_m, xy1_m, xy1_mt, scale_err, xy_err, ori_err'.split(', '))
         >>> #---------------
         >>> # xdoctest: +REQUIRES(--show)
+        >>> import plottool_ibeis as pt
         >>> pt.figure(fnum=1, pnum=(1, 2, 1), title='orig points and offset point')
         >>> segments_list1 = np.array(list(zip(xy1_m.T.tolist(), off_xy1_m.T.tolist())))
         >>> pt.draw_line_segments(segments_list1, color=pt.LIGHT_BLUE)
@@ -871,11 +874,11 @@ def refine_inliers(kpts1, kpts2, fm, aff_inliers, xy_thresh_sqrd,
         >>> # DISABLE_DOCTEST
         >>> from vtool_ibeis.spatial_verification import *  # NOQA
         >>> import vtool_ibeis.keypoint as ktool
-        >>> import plottool_ibeis as pt
         >>> kpts1, kpts2, fm, aff_inliers, rchip1, rchip2, xy_thresh_sqrd = testdata_matching_affine_inliers()
         >>> homog_tup1 = refine_inliers(kpts1, kpts2, fm, aff_inliers, xy_thresh_sqrd)
         >>> homog_tup = (homog_tup1[0], homog_tup1[2])
         >>> # xdoctest: +REQUIRES(--show)
+        >>> import plottool_ibeis as pt
         >>> pt.draw_sv.show_sv(rchip1, rchip2, kpts1, kpts2, fm, homog_tup=homog_tup)
         >>> ut.show_if_requested()
 
@@ -955,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)
@@ -990,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

@@ -1,8 +1,6 @@
-# -*- coding: utf-8 -*-
 """
 Sympy helpers
 """
-from __future__ import absolute_import, division, print_function
 import numpy as np
 import six
 import utool as ut

vtool_ibeis/trig.py

@@ -1,5 +1,4 @@
 # LICENCE
-from __future__ import absolute_import, division, print_function
 import numpy as np
 from .util_math import TAU
 

vtool_ibeis/util_math.py

@@ -1,14 +1,11 @@
-# -*- coding: utf-8 -*-
 """
 # LICENCE Apache 2 or whatever
 
 FIXME: monotization functions need more hueristics
 """
-from __future__ import absolute_import, division, print_function, unicode_literals
 import numpy as np
-import utool as ut
-import ubelt as ub
-from six.moves import range, zip
+import utool as ut  # NOQA
+import ubelt as ub  # NOQA
 
 
 TAU = np.pi * 2  # References: tauday.com
@@ -484,7 +481,7 @@ def test_language_modulus():
         http://en.wikipedia.org/wiki/Modulo_operation
     """
     import math
-    import utool as ut
+    import utool as ut  # NOQA
     TAU = math.pi * 2
     num_list = [-8, -1, 0, 1, 2, 6, 7, 29]
     modop_result_list = []

{vtool_ibeis-2.2.0.dist-info → vtool_ibeis-2.3.0.dist-info}/LICENSE

@@ -1,4 +1,4 @@
-Apache License
+                                 Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
 
@@ -178,7 +178,7 @@ Apache License
    APPENDIX: How to apply the Apache License to your work.
 
       To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
+      boilerplate notice, with the fields enclosed by brackets "[]"
       replaced with your own identifying information. (Don't include
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
@@ -186,7 +186,7 @@ Apache License
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright {yyyy} {name of copyright owner}
+   Copyright 2022 "Jon Crall"
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -198,4 +198,4 @@ Apache License
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
-   limitations under the License.
+   limitations under the License.