def new(cls, depc, qaid_list, daid_list, cfgdict=None, tablename=None):
parent_rowids = cls.make_parent_rowids(qaid_list, daid_list)
parent_rowids = list(ut.product_nonsame(qaid_list, daid_list))
request = cls.static_new(cls, depc, parent_rowids, cfgdict, tablename)
request.qaids = safeop(np.array, qaid_list)
request.daids = safeop(np.array, daid_list)
return request
def new(cls, depc, qaid_list, daid_list, cfgdict=None, tablename=None):
parent_rowids = cls.make_parent_rowids(qaid_list, daid_list)
parent_rowids = list(ut.product_nonsame(qaid_list, daid_list))
request = cls.static_new(cls, depc, parent_rowids, cfgdict, tablename)
request.qaids = safeop(np.array, qaid_list)
request.daids = safeop(np.array, daid_list)
return request
def get_review_rowids_between(ibs, aids1, aids2=None, method=None):
"""
Find staging rowids between sets of aids
Doctest:
>>> from wbia.control.manual_review_funcs import *
>>> import wbia
>>> ibs = wbia.opendb('PZ_MTEST')
>>> aids1 = aids2 = [1, 2, 3, 4, 5, 6]
>>> rowids_between = ibs.get_review_rowids_between
>>> ids1 = sorted(rowids_between(aids1, aids2, method=1))
>>> ids2 = sorted(rowids_between(aids1, aids2, method=2))
>>> assert len(ub.find_duplicates(ids1)) == 0
>>> assert len(ub.find_duplicates(ids2)) == 0
>>> assert ids1 == ids2
"""
if aids2 is None:
aids2 = aids1
if method is None:
if len(aids1) * len(aids2) > 5000:
method = 1
else:
method = 2
if method == 1:
# Strategy 1: get all existing rows and see what intersects
# This is better when the enumerated set of rows would be larger than
# the database size
rowids11 = set(ut.flatten(ibs.get_review_rowids_from_aid1(aids1)))
rowids12 = set(ut.flatten(ibs.get_review_rowids_from_aid2(aids1)))
if aids1 is aids2:
rowids = list(reduce(set.intersection, [rowids11, rowids12]))
else:
rowids21 = set(ut.flatten(ibs.get_review_rowids_from_aid1(aids2)))
rowids22 = set(ut.flatten(ibs.get_review_rowids_from_aid2(aids2)))
rowids = list(
reduce(set.intersection, [rowids11, rowids12, rowids21, rowids22])
)
elif method == 2:
# Strategy 2: enumerate what rows could exist and see what does exist
# This is better when the enumerated set of rows would be smaller than
# the database size
edges = list(ut.product_nonsame(aids1, aids2))
if len(edges) == 0:
rowids = []
else:
rowids = ibs.get_review_rowids_from_edges(edges, directed=True)
if rowids is None:
rowids = []
rowids = ut.filter_Nones(rowids)
rowids = ut.flatten(rowids)
else:
raise ValueError('no method=%r' % (method,))
return rowids
def random_case_set():
r"""
Returns:
tuple: (labels, pairwise_feats)
CommandLine:
python -m ibeis.algo.hots.testem random_case_set --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.testem import * # NOQA
>>> (labels, pairwise_feats) = random_case_set()
>>> result = ('(labels, pairwise_feats) = %s' % (ut.repr2((labels, pairwise_feats)),))
>>> print(result)
"""
rng = np.random.RandomState(0)
case_params = dict(num_names=5, rng=rng)
num_annots = 600
test_cases = [
random_test_annot(**case_params)
for _ in ut.ProgIter(range(num_annots), bs=1)
]
pairxs = list(ut.product_nonsame(range(num_annots), range(num_annots)))
import utool
utool.embed()
test_pairs = list(ut.unflat_take(test_cases, pairxs))
cases1 = ut.instancelist(ut.take_column(test_pairs, 0), check=False)
cases2 = ut.instancelist(ut.take_column(test_pairs, 1), check=False)
# FIXME
labels = labels1 = make_test_pairwise_labels2(cases1, cases2) # NOQA
#labels = np.array([make_test_pairwise_labels(case1, case2)
# for case1, case2 in ut.ProgIter(test_pairs, bs=1)])
pairwise_feats_ = [
make_test_pairwise_fetaures(case1, case2, label, rng)
for label, (case1,
case2) in ut.ProgIter(list(zip(labels, test_pairs)), bs=1)
]
pairwise_feats = np.vstack(pairwise_feats_)
print(ut.dict_hist(labels))
return labels, pairwise_feats
def random_case_set():
r"""
Returns:
tuple: (labels, pairwise_feats)
CommandLine:
python -m ibeis.algo.hots.testem random_case_set --show
Example:
>>> # DISABLE_DOCTEST
>>> from ibeis.algo.hots.testem import * # NOQA
>>> (labels, pairwise_feats) = random_case_set()
>>> result = ('(labels, pairwise_feats) = %s' % (ut.repr2((labels, pairwise_feats)),))
>>> print(result)
"""
rng = np.random.RandomState(0)
case_params = dict(num_names=5, rng=rng)
num_annots = 600
test_cases = [random_test_annot(**case_params) for _ in ut.ProgIter(range(num_annots), bs=1)]
pairxs = list(ut.product_nonsame(range(num_annots), range(num_annots)))
import utool
utool.embed()
test_pairs = list(ut.unflat_take(test_cases, pairxs))
cases1 = ut.make_instancelist(ut.take_column(test_pairs, 0), check=False)
cases2 = ut.make_instancelist(ut.take_column(test_pairs, 1), check=False)
# FIXME
labels = labels1 = make_test_pairwise_labels2(cases1, cases2) # NOQA
#labels = np.array([make_test_pairwise_labels(case1, case2)
# for case1, case2 in ut.ProgIter(test_pairs, bs=1)])
pairwise_feats_ = [make_test_pairwise_fetaures(case1, case2, label, rng)
for label, (case1, case2) in ut.ProgIter(list(zip(labels, test_pairs)), bs=1)]
pairwise_feats = np.vstack(pairwise_feats_)
print(ut.dict_hist(labels))
return labels, pairwise_feats
def get_annotmatch_rowids_between(ibs, aids1, aids2, method=None):
"""
Example:
>>> # ENABLE_DOCTEST
>>> from wbia.annotmatch_funcs import * # NOQA
>>> import wbia
>>> ibs = wbia.opendb('PZ_MTEST')
>>> aids1 = aids2 = [1, 2, 3, 4, 5, 6]
>>> rowids_between = ibs.get_annotmatch_rowids_between
>>> ams1 = sorted(rowids_between(aids1, aids2, method=1))
>>> ams2 = sorted(rowids_between(aids1, aids2, method=2))
>>> assert len(ub.find_duplicates(ams1)) == 0
>>> assert len(ub.find_duplicates(ams2)) == 0
>>> assert sorted(ams2) == sorted(ams1)
"""
if method is None:
if len(aids1) * len(aids2) > 5000:
method = 1
else:
method = 2
if method == 1:
# Strategy 1: get all existing rows and see what intersects
# This is better when the enumerated set of rows would be larger than
# the database size
unflat_rowids1L = ibs.get_annotmatch_rowids_from_aid1(aids1)
unflat_rowids1R = ibs.get_annotmatch_rowids_from_aid2(aids1)
unflat_rowids2L = ibs.get_annotmatch_rowids_from_aid1(aids2)
unflat_rowids2R = ibs.get_annotmatch_rowids_from_aid2(aids2)
am_rowids1L = {
r
for r in ut.iflatten(unflat_rowids1L) if r is not None
}
am_rowids1R = {
r
for r in ut.iflatten(unflat_rowids1R) if r is not None
}
am_rowids2L = {
r
for r in ut.iflatten(unflat_rowids2L) if r is not None
}
am_rowids2R = {
r
for r in ut.iflatten(unflat_rowids2R) if r is not None
}
ams12 = am_rowids1L.intersection(am_rowids2R)
ams21 = am_rowids2L.intersection(am_rowids1R)
ams = sorted(ams12.union(ams21))
# ams = sorted(am_rowids1.intersection(am_rowids2))
# rowids2 = ibs.get_annotmatch_rowids_from_aid2(aid_list)
# unflat_rowids1 = ibs.get_annotmatch_rowids_from_aid(aids1)
# unflat_rowids2 = ibs.get_annotmatch_rowids_from_aid(aids2)
# am_rowids1 = {r for r in ut.iflatten(unflat_rowids1) if r is not None}
# am_rowids2 = {r for r in ut.iflatten(unflat_rowids2) if r is not None}
# ams = sorted(am_rowids1.intersection(am_rowids2))
# ams = ut.isect(am_rowids1, am_rowids2)
elif method == 2:
# Strategy 2: enumerate what rows could exist and see what does exist
# This is better when the enumerated set of rows would be smaller than
# the database size
edges = list(ut.product_nonsame(aids1, aids2))
if len(edges) == 0:
ams = []
else:
aids1_, aids2_ = ut.listT(edges)
# ams = ibs.get_annotmatch_rowid_from_undirected_superkey(aids1_, aids2_)
ams = ibs.get_annotmatch_rowid_from_superkey(aids1_, aids2_)
if ams is None:
ams = []
ams = ut.filter_Nones(ams)
return ams
def make_parent_rowids(qaid_list, daid_list):
return list(ut.product_nonsame(qaid_list, daid_list))
def make_parent_rowids(qaid_list, daid_list):
return list(ut.product_nonsame(qaid_list, daid_list))
