vtool-ibeis 2.3.0__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.3.0'
+__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/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/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):
@@ -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])

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')

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:
@@ -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
 
@@ -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)

vtool_ibeis/inspect_matches.py

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

vtool_ibeis/keypoint.py

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

vtool_ibeis/other.py

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

vtool_ibeis/score_normalization.py

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

vtool_ibeis/symbolic.py

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