def test_average_contrast():
import vtool as vt
ut.get_valid_test_imgkeys()
img_fpath_list = [ut.grab_test_imgpath(key) for key in ut.get_valid_test_imgkeys()]
img_list = [vt.imread(img, grayscale=True) for img in img_fpath_list]
avecontrast_list = np.array([compute_average_contrast(img) for img in img_list])
import plottool as pt
nCols = len(img_list)
fnum = None
if fnum is None:
fnum = pt.next_fnum()
pt.figure(fnum=fnum, pnum=(2, 1, 1))
sortx = avecontrast_list.argsort()
y_list = avecontrast_list[sortx]
x_list = np.arange(0, nCols) + .5
pt.plot(x_list, y_list, 'bo-')
sorted_imgs = ut.take(img_list, sortx)
for px, img in ut.ProgressIter(enumerate(sorted_imgs, start=1)):
pt.imshow(img, fnum=fnum, pnum=(2, nCols, nCols + px))
def test_average_contrast():
import vtool as vt
ut.get_valid_test_imgkeys()
img_fpath_list = [
ut.grab_test_imgpath(key) for key in ut.get_valid_test_imgkeys()
]
img_list = [vt.imread(img, grayscale=True) for img in img_fpath_list]
avecontrast_list = np.array(
[compute_average_contrast(img) for img in img_list])
import plottool as pt
nCols = len(img_list)
fnum = None
if fnum is None:
fnum = pt.next_fnum()
pt.figure(fnum=fnum, pnum=(2, 1, 1))
sortx = avecontrast_list.argsort()
y_list = avecontrast_list[sortx]
x_list = np.arange(0, nCols) + .5
pt.plot(x_list, y_list, 'bo-')
sorted_imgs = ut.take(img_list, sortx)
for px, img in ut.ProgressIter(enumerate(sorted_imgs, start=1)):
pt.imshow(img, fnum=fnum, pnum=(2, nCols, nCols + px))
def _test_buffered_generator3():
"""
CommandLine:
python -m utool.util_parallel --test-_test_buffered_generator3
This test suggests that a ut.buffered_generator is better for disk IO than
ut.generate
Example:
>>> from utool.util_parallel import * # NOQA
>>> _test_buffered_generator3()
"""
import vtool as vt
import utool as ut
# ---- Func and Sleep Definitions
args = list(map(ut.grab_test_imgpath, ut.get_valid_test_imgkeys()))
func = vt.imread
def sleepfunc(prime=346373):
#time.sleep(.1)
import utool as ut
[ut.is_prime(prime) for _ in range(2)]
_test_buffered_generator_general(func, args, sleepfunc, 4.0)
def _test_buffered_generator3():
"""
CommandLine:
python -m utool.util_parallel --test-_test_buffered_generator3
This test suggests that a ut.buffered_generator is better for disk IO than
ut.generate
Example:
>>> from utool.util_parallel import * # NOQA
>>> _test_buffered_generator3()
"""
import vtool as vt
import utool as ut
# ---- Func and Sleep Definitions
args = list(map(ut.grab_test_imgpath, ut.get_valid_test_imgkeys()))
func = vt.imread
def sleepfunc(prime=346373):
#time.sleep(.1)
import utool as ut
[ut.is_prime(prime) for _ in range(2)]
_test_buffered_generator_general(func, args, sleepfunc, 4.0)
def testdata_depc(fname=None):
"""
Example of local registration
"""
import dtool
import vtool as vt
gpath_list = ut.lmap(ut.grab_test_imgpath,
ut.get_valid_test_imgkeys(),
verbose=False)
dummy_root = 'dummy_annot'
def get_root_uuid(aid_list):
return ut.lmap(ut.hashable_to_uuid, aid_list)
# put the test cache in the dtool repo
dtool_repo = dirname(ut.get_module_dir(dtool))
cache_dpath = join(dtool_repo, 'DEPCACHE')
depc = dtool.DependencyCache(
root_tablename=dummy_root,
default_fname=fname,
cache_dpath=cache_dpath,
get_root_uuid=get_root_uuid,
#root_asobject=root_asobject,
use_globals=False)
@depc.register_preproc(tablename='chip',
parents=[dummy_root],
colnames=['size', 'chip'],
coltypes=[(int, int),
('extern', vt.imread, vt.imwrite)],
configclass=DummyChipConfig)
def dummy_preproc_chip(depc, annot_rowid_list, config=None):
"""
TODO: Infer properties from docstr?
Args:
depc (dtool.DependencyCache):
annot_rowid_list (list): list of annot rowids
config (dict): config dictionary
Returns:
tuple : ((int, int), ('extern', vt.imread))
"""
if config is None:
config = {}
# Demonstates using asobject to get input to function as a dictionary
# of properties
#for annot in annot_list:
#print('[preproc] Computing chips of aid=%r' % (aid,))
print('[preproc] Computing chips')
for aid in annot_rowid_list:
#aid = annot['aid']
#chip_fpath = annot['gpath']
chip_fpath = gpath_list[aid]
#w, h = vt.image.open_image_size(chip_fpath)
chip = vt.imread(chip_fpath)
size = vt.get_size(chip)
#size = (w, h)
print('Dummpy preproc chip yeilds')
print('* chip_fpath = %r' % (chip_fpath, ))
print('* size = %r' % (size, ))
#yield size, chip_fpath
yield size, chip
@depc.register_preproc(
'probchip',
[dummy_root],
['size', 'probchip'],
coltypes=[(int, int), ('extern', vt.imread, vt.imwrite, '.png')],
configclass=ProbchipConfig,
)
def dummy_preproc_probchip(depc, root_rowids, config):
print('[preproc] Computing probchip')
for rowid in root_rowids:
if config['testerror']:
if rowid % 2 == 0:
# Test error yeilds None on even rowids
yield None
continue
rng = np.random.RandomState(rowid)
probchip = rng.randint(0, 255, size=(64, 64))
#probchip = np.zeros((64, 64))
size = (rowid, rowid)
yield size, probchip
@depc.register_preproc(
'keypoint',
['chip'],
['kpts', 'num'],
[np.ndarray, int],
#default_onthefly=True,
configclass=DummyKptsConfig,
docstr='Used to store individual chip features (ellipses)',
)
def dummy_preproc_kpts(depc, chip_rowids, config=None):
if config is None:
config = {}
print('config = %r' % (config, ))
adapt_shape = config['adapt_shape']
print('[preproc] Computing kpts')
ut.assert_all_not_None(chip_rowids, 'chip_rowids')
# This is in here to attempt to trigger a failure of the chips dont
# exist and the feature cache is called.
chip_fpath_list = depc.get_native('chip',
chip_rowids,
'chip',
read_extern=False)
print('computing featurse from chip_fpath_list = %r' %
(chip_fpath_list, ))
for rowid in chip_rowids:
if adapt_shape:
kpts = np.zeros((7 + rowid, 6)) + rowid
else:
kpts = np.ones((7 + rowid, 6)) + rowid
num = len(kpts)
yield kpts, num
@depc.register_preproc(
'descriptor',
['keypoint'],
['vecs'],
[np.ndarray],
)
def dummy_preproc_vecs(depc, kp_rowid, config=None):
if config is None:
config = {}
print('[preproc] Computing vecs')
for rowid in kp_rowid:
yield np.ones((7 + rowid, 8), dtype=np.uint8) + rowid,
@depc.register_preproc(
'fgweight',
['keypoint', 'probchip'],
['fgweight'],
[np.ndarray],
)
def dummy_preproc_fgweight(depc, kpts_rowid, probchip_rowid, config=None):
if config is None:
config = {}
print('[preproc] Computing fgweight')
for rowid1, rowid2 in zip(kpts_rowid, probchip_rowid):
yield np.ones(7 + rowid1),
@depc.register_preproc(tablename='vsmany',
colnames='annotmatch',
coltypes=DummyAnnotMatch,
requestclass=DummyVsManyRequest,
configclass=DummyVsManyConfig)
def vsmany_matching(depc, qaids, config=None):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
print('RUNNING DUMMY VSMANY ALGO')
daids = config.daids
qaids = qaids
sver_on = config.dummy_sver_cfg['sver_on']
kpts_list = depc.get_property('keypoint', list(qaids)) # NOQA
#dummy_preproc_kpts
for qaid in qaids:
dnid_list = [1, 1, 2, 2]
unique_nids = [1, 2]
if sver_on:
annot_score_list = [.2, .2, .4, .5]
name_score_list = [.2, .5]
else:
annot_score_list = [.3, .3, .6, .9]
name_score_list = [.1, .7]
annot_match = DummyAnnotMatch(qaid, daids, dnid_list,
annot_score_list, unique_nids,
name_score_list)
yield annot_match
SIMPLE = 0
if not SIMPLE:
@depc.register_preproc(tablename='chipmask',
parents=[dummy_root],
colnames=['size', 'mask'],
coltypes=[(int, int),
('extern', vt.imread, vt.imwrite)])
def dummy_manual_chipmask(depc, parent_rowids, config=None):
import vtool as vt
from plottool import interact_impaint
mask_dpath = join(depc.cache_dpath, 'ManualChipMask')
ut.ensuredir(mask_dpath)
if config is None:
config = {}
print('Requesting user defined chip mask')
for rowid in parent_rowids:
img = vt.imread(gpath_list[rowid])
mask = interact_impaint.impaint_mask2(img)
mask_fpath = join(mask_dpath, 'mask%d.png' % (rowid, ))
vt.imwrite(mask_fpath, mask)
w, h = vt.get_size(mask)
yield (w, h), mask_fpath
@depc.register_preproc(
'notch',
[dummy_root],
['notchdata'],
[np.ndarray],
)
def dummy_preproc_notch(depc, parent_rowids, config=None):
if config is None:
config = {}
print('[preproc] Computing notch')
for rowid in parent_rowids:
yield np.empty(5 + rowid),
@depc.register_preproc(
'spam',
['fgweight', 'chip', 'keypoint'],
['spam', 'eggs', 'size', 'uuid', 'vector', 'textdata'],
[
str, int, (int, int), uuid.UUID, np.ndarray,
('extern', ut.readfrom)
],
docstr='I dont like spam',
)
def dummy_preproc_spam(depc, *args, **kwargs):
config = kwargs.get('config', None)
if config is None:
config = {}
print('[preproc] Computing spam')
ut.writeto('tmp.txt', ut.lorium_ipsum())
for x in zip(*args):
size = (42, 21)
uuid = ut.get_zero_uuid()
vector = np.ones(3)
yield ('spam', 3665, size, uuid, vector, 'tmp.txt')
@depc.register_preproc(
'nnindexer',
['keypoint*'],
['flann'],
[str], # [('extern', ut.load_data)],
configclass=DummyIndexerConfig,
)
def dummy_preproc_indexer(depc, parent_rowids_list, config=None):
print('COMPUTING DUMMY INDEXER')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for parent_rowids in parent_rowids_list:
yield ('really cool flann object' + str(config.get_cfgstr()) +
' ' + str(parent_rowids), )
@depc.register_preproc(
'notchpair',
['notch', 'notch'],
['pairscore'],
[int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_notchpair(depc, n1, n2, config=None):
print('COMPUTING MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for nn1, nn2 in zip(n1, n2):
yield (nn1 + nn2, )
@depc.register_preproc(
'multitest',
[
'keypoint', 'notch', 'notch', 'fgweight*', 'notchpair*',
'notchpair*', 'notchpair', 'nnindexer'
],
['foo'],
[str], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_multitest(depc, *args, **kwargs):
print('COMPUTING MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for x in zip(args):
yield ('cool multi object' + str(kwargs) + ' ' + str(x), )
# TEST MULTISET DEPENDENCIES
@depc.register_preproc(
'multitest_score',
['multitest'],
['score'],
[int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_multitest_score(depc, parent_rowids, config=None):
print('COMPUTING DEPENDENCY OF MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for parent_rowids in zip(parent_rowids):
yield (parent_rowids, )
# TEST MULTISET DEPENDENCIES
@depc.register_preproc(
'multitest_score_x',
['multitest_score', 'multitest_score'],
['score'],
[int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def multitest_score_x(depc, *args, **kwargs):
raise NotImplementedError('hack')
# REGISTER MATCHING ALGORITHMS
@depc.register_preproc(
tablename='neighbs',
colnames=['qx2_idx', 'qx2_dist'],
coltypes=[np.ndarray, np.ndarray],
parents=['keypoint', 'fgweight', 'nnindexer', 'nnindexer'])
def neighbs(depc, *args, **kwargs):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
#dummy_preproc_kpts
for qaid in zip(args):
yield np.array([qaid]), np.array([qaid])
@depc.register_preproc(tablename='neighbs_score',
colnames=['qx2_dist'],
coltypes=[np.ndarray],
parents=['neighbs'])
def neighbs_score(depc, *args, **kwargs):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
raise NotImplementedError('hack')
@depc.register_preproc('vsone', [dummy_root, dummy_root],
['score', 'match_obj', 'fm'],
[float, DummyVsOneMatch, np.ndarray],
requestclass=DummyVsOneRequest,
configclass=DummyVsOneConfig,
chunksize=2)
def compute_vsone_matching(depc, qaids, daids, config):
"""
CommandLine:
python -m dtool.base --exec-VsOneSimilarityRequest
"""
print('RUNNING DUMMY VSONE ALGO')
for qaid, daid in zip(qaids, daids):
match = DummyVsOneMatch()
match.qaid = qaid
match.daid = daid
match.fm = np.array([[1, 2], [3, 4]])
score = match.score = qaid + daid
yield (score, match, match.fm)
# table = depc['spam']
# print(ut.repr2(table.get_addtable_kw(), nl=2))
depc.initialize()
# table.print_schemadef()
# print(table.db.get_schema_current_autogeneration_str())
return depc
def testdata_depc(fname=None):
import vtool as vt
gpath_list = ut.lmap(ut.grab_test_imgpath, ut.get_valid_test_imgkeys(), verbose=False)
dummy_root = 'dummy_annot'
def root_asobject(aid):
""" Convinience for writing preproc funcs """
gpath = gpath_list[aid]
root_obj = ut.LazyDict({
'aid': aid,
'gpath': gpath,
'image': lambda: vt.imread(gpath)
})
return root_obj
depc = DependencyCache(root_tablename=dummy_root, default_fname=fname,
root_asobject=root_asobject, use_globals=False)
_register_preproc = depc.register_preproc
@_register_preproc(
tablename='chipmask', parents=[dummy_root], colnames=['size', 'mask'],
coltypes=[(int, int), ('extern', vt.imread, vt.imwrite)])
def dummy_manual_chipmask(depc, parent_rowids, config=None):
import vtool as vt
from plottool import interact_impaint
mask_dpath = ut.unixjoin(depc.cache_dpath, 'ManualChipMask')
ut.ensuredir(mask_dpath)
if config is None:
config = {}
print('Requesting user defined chip mask')
for rowid in parent_rowids:
img = vt.imread(gpath_list[rowid])
mask = interact_impaint.impaint_mask2(img)
mask_fpath = ut.unixjoin(mask_dpath, 'mask%d.png' % (rowid,))
vt.imwrite(mask_fpath, mask)
w, h = vt.get_size(mask)
yield (w, h), mask_fpath
@_register_preproc(
tablename='chip', parents=[dummy_root], colnames=['size', 'chip'],
coltypes=[(int, int), vt.imread], asobject=True)
def dummy_preproc_chip(depc, annot_list, config=None):
"""
TODO: Infer properties from docstr
Args:
annot_list (list): list of annot objects
config (dict): config dictionary
Returns:
tuple : ((int, int), ('extern', vt.imread))
"""
if config is None:
config = {}
# Demonstates using asobject to get input to function as a dictionary
# of properties
for annot in annot_list:
print('Computing chips of annot=%r' % (annot,))
chip_fpath = annot['gpath']
w, h = vt.image.open_image_size(chip_fpath)
size = (w, h)
print('* chip_fpath = %r' % (chip_fpath,))
print('* size = %r' % (size,))
yield size, chip_fpath
@_register_preproc(
'probchip', [dummy_root], ['size', 'probchip'],
coltypes=[(int, int), ('extern', vt.imread)])
def dummy_preproc_probchip(depc, parent_rowids, config=None):
if config is None:
config = {}
print('Computing probchip')
for rowid in parent_rowids:
yield (rowid, rowid), 'probchip.jpg'
@_register_preproc(
'keypoint', ['chip'], ['kpts', 'num'], [np.ndarray, int],
docstr='Used to store individual chip features (ellipses)',)
def dummy_preproc_kpts(depc, parent_rowids, config=None):
if config is None:
config = {}
print('Computing kpts')
for rowid in parent_rowids:
yield np.ones((7 + rowid, 6)) + rowid, 7 + rowid
@_register_preproc('descriptor', ['keypoint'], ['vecs'], [np.ndarray],)
def dummy_preproc_vecs(depc, parent_rowids, config=None):
if config is None:
config = {}
print('Computing vecs')
for rowid in parent_rowids:
yield np.ones((7 + rowid, 8), dtype=np.uint8) + rowid,
@_register_preproc('fgweight', ['keypoint', 'probchip'], ['fgweight'], [np.ndarray],)
def dummy_preproc_fgweight(depc, kpts_rowid, probchip_rowid, config=None):
if config is None:
config = {}
print('Computing fgweight')
for rowid1, rowid2 in zip(kpts_rowid, probchip_rowid):
yield np.ones(7 + rowid1),
@_register_preproc('notch', [dummy_root], ['notchdata'],)
def dummy_preproc_notch(depc, parent_rowids, config=None):
if config is None:
config = {}
print('Computing notch')
for rowid in parent_rowids:
yield np.empty(5 + rowid),
@_register_preproc('spam', ['fgweight', 'chip', 'keypoint'],
['spam', 'eggs', 'size', 'uuid', 'vector', 'textdata'],
[str, int, (int, int), uuid.UUID, np.ndarray, ('extern', ut.readfrom)],
docstr='I dont like spam',)
def dummy_preproc_spam(depc, *args, **kwargs):
config = kwargs.get('config', None)
if config is None:
config = {}
print('Computing notch')
ut.writeto('tmp.txt', ut.lorium_ipsum())
for x in zip(*args):
size = (42, 21)
uuid = ut.get_zero_uuid()
vector = np.ones(3)
yield ('spam', 3665, size, uuid, vector, 'tmp.txt')
# table = depc['spam']
# print(ut.repr2(table.get_addtable_kw(), nl=2))
depc.initialize()
# table.print_schemadef()
# print(table.db.get_schema_current_autogeneration_str())
return depc
def testdata_depc(fname=None):
"""
Example of local registration
"""
import dtool
import vtool as vt
gpath_list = ut.lmap(ut.grab_test_imgpath, ut.get_valid_test_imgkeys(),
verbose=False)
dummy_root = 'dummy_annot'
def get_root_uuid(aid_list):
return ut.lmap(ut.hashable_to_uuid, aid_list)
# put the test cache in the dtool repo
dtool_repo = dirname(ut.get_module_dir(dtool))
cache_dpath = join(dtool_repo, 'DEPCACHE')
depc = dtool.DependencyCache(
root_tablename=dummy_root, default_fname=fname,
cache_dpath=cache_dpath,
get_root_uuid=get_root_uuid,
#root_asobject=root_asobject,
use_globals=False)
@depc.register_preproc(tablename='chip', parents=[dummy_root],
colnames=['size', 'chip'],
coltypes=[(int, int), ('extern', vt.imread, vt.imwrite)],
configclass=DummyChipConfig)
def dummy_preproc_chip(depc, annot_rowid_list, config=None):
"""
TODO: Infer properties from docstr?
Args:
depc (dtool.DependencyCache):
annot_rowid_list (list): list of annot rowids
config (dict): config dictionary
Returns:
tuple : ((int, int), ('extern', vt.imread))
"""
if config is None:
config = {}
# Demonstates using asobject to get input to function as a dictionary
# of properties
#for annot in annot_list:
#print('[preproc] Computing chips of aid=%r' % (aid,))
print('[preproc] Computing chips')
for aid in annot_rowid_list:
#aid = annot['aid']
#chip_fpath = annot['gpath']
chip_fpath = gpath_list[aid]
#w, h = vt.image.open_image_size(chip_fpath)
chip = vt.imread(chip_fpath)
size = vt.get_size(chip)
#size = (w, h)
#print('* chip_fpath = %r' % (chip_fpath,))
#print('* size = %r' % (size,))
#yield size, chip_fpath
yield size, chip
@depc.register_preproc(
'probchip', [dummy_root], ['size', 'probchip'],
coltypes=[(int, int), ('extern', vt.imread, vt.imwrite, '.png')],
configclass=ProbchipConfig,
)
def dummy_preproc_probchip(depc, root_rowids, config):
print('[preproc] Computing probchip')
for rowid in root_rowids:
if config['testerror']:
if rowid % 2 == 0:
# Test error yeilds None on even rowids
yield None
continue
rng = np.random.RandomState(rowid)
probchip = rng.randint(0, 255, size=(64, 64))
#probchip = np.zeros((64, 64))
size = (rowid, rowid)
yield size, probchip
@depc.register_preproc(
'keypoint', ['chip'], ['kpts', 'num'], [np.ndarray, int],
#default_onthefly=True,
configclass=DummyKptsConfig,
docstr='Used to store individual chip features (ellipses)',)
def dummy_preproc_kpts(depc, chip_rowids, config=None):
if config is None:
config = {}
print('config = %r' % (config,))
adapt_shape = config['adapt_shape']
print('[preproc] Computing kpts')
for rowid in chip_rowids:
if adapt_shape:
kpts = np.zeros((7 + rowid, 6)) + rowid
else:
kpts = np.ones((7 + rowid, 6)) + rowid
num = len(kpts)
yield kpts, num
@depc.register_preproc('descriptor', ['keypoint'], ['vecs'], [np.ndarray],)
def dummy_preproc_vecs(depc, kp_rowid, config=None):
if config is None:
config = {}
print('[preproc] Computing vecs')
for rowid in kp_rowid:
yield np.ones((7 + rowid, 8), dtype=np.uint8) + rowid,
@depc.register_preproc('fgweight', ['keypoint', 'probchip'], ['fgweight'], [np.ndarray],)
def dummy_preproc_fgweight(depc, kpts_rowid, probchip_rowid, config=None):
if config is None:
config = {}
print('[preproc] Computing fgweight')
for rowid1, rowid2 in zip(kpts_rowid, probchip_rowid):
yield np.ones(7 + rowid1),
@depc.register_preproc(
tablename='vsmany', colnames='annotmatch', coltypes=DummyAnnotMatch,
requestclass=DummyVsManyRequest, configclass=DummyVsManyConfig)
def vsmany_matching(depc, qaids, config=None):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
print('RUNNING DUMMY VSMANY ALGO')
daids = config.daids
qaids = qaids
sver_on = config.dummy_sver_cfg['sver_on']
kpts_list = depc.get_property('keypoint', qaids) # NOQA
#dummy_preproc_kpts
for qaid in qaids:
dnid_list = [1, 1, 2, 2]
unique_nids = [1, 2]
if sver_on:
annot_score_list = [.2, .2, .4, .5]
name_score_list = [.2, .5]
else:
annot_score_list = [.3, .3, .6, .9]
name_score_list = [.1, .7]
annot_match = DummyAnnotMatch(qaid, daids, dnid_list,
annot_score_list, unique_nids,
name_score_list)
yield annot_match
SIMPLE = 0
if not SIMPLE:
@depc.register_preproc(
tablename='chipmask', parents=[dummy_root], colnames=['size', 'mask'],
coltypes=[(int, int), ('extern', vt.imread, vt.imwrite)])
def dummy_manual_chipmask(depc, parent_rowids, config=None):
import vtool as vt
from plottool import interact_impaint
mask_dpath = join(depc.cache_dpath, 'ManualChipMask')
ut.ensuredir(mask_dpath)
if config is None:
config = {}
print('Requesting user defined chip mask')
for rowid in parent_rowids:
img = vt.imread(gpath_list[rowid])
mask = interact_impaint.impaint_mask2(img)
mask_fpath = join(mask_dpath, 'mask%d.png' % (rowid,))
vt.imwrite(mask_fpath, mask)
w, h = vt.get_size(mask)
yield (w, h), mask_fpath
@depc.register_preproc('notch', [dummy_root], ['notchdata'], [np.ndarray],)
def dummy_preproc_notch(depc, parent_rowids, config=None):
if config is None:
config = {}
print('[preproc] Computing notch')
for rowid in parent_rowids:
yield np.empty(5 + rowid),
@depc.register_preproc(
'spam', ['fgweight', 'chip', 'keypoint'],
['spam', 'eggs', 'size', 'uuid', 'vector', 'textdata'],
[str, int, (int, int), uuid.UUID, np.ndarray, ('extern', ut.readfrom)],
docstr='I dont like spam',)
def dummy_preproc_spam(depc, *args, **kwargs):
config = kwargs.get('config', None)
if config is None:
config = {}
print('[preproc] Computing spam')
ut.writeto('tmp.txt', ut.lorium_ipsum())
for x in zip(*args):
size = (42, 21)
uuid = ut.get_zero_uuid()
vector = np.ones(3)
yield ('spam', 3665, size, uuid, vector, 'tmp.txt')
@depc.register_preproc(
'nnindexer', ['keypoint*'], ['flann'], [str], # [('extern', ut.load_data)],
configclass=DummyIndexerConfig,
)
def dummy_preproc_indexer(depc, parent_rowids_list, config=None):
print('COMPUTING DUMMY INDEXER')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for parent_rowids in parent_rowids_list:
yield ('really cool flann object' + str(config.get_cfgstr()) + ' ' + str(parent_rowids),)
@depc.register_preproc(
'notchpair', ['notch', 'notch'], ['pairscore'], [int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_notchpair(depc, n1, n2, config=None):
print('COMPUTING MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for nn1, nn2 in zip(n1, n2):
yield (nn1 + nn2,)
@depc.register_preproc(
'multitest', ['keypoint', 'notch', 'notch', 'fgweight*', 'notchpair*', 'notchpair*', 'notchpair', 'nnindexer'], ['foo'], [str], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_multitest(depc, *args, **kwargs):
print('COMPUTING MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for x in zip(args):
yield ('cool multi object' + str(kwargs) + ' ' + str(x),)
# TEST MULTISET DEPENDENCIES
@depc.register_preproc(
'multitest_score', ['multitest'], ['score'], [int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def dummy_multitest_score(depc, parent_rowids, config=None):
print('COMPUTING DEPENDENCY OF MULTITEST 1 ')
#assert len(parent_rowids_list) == 1, 'handles only one indexer'
for parent_rowids in zip(parent_rowids):
yield (parent_rowids,)
# TEST MULTISET DEPENDENCIES
@depc.register_preproc(
'multitest_score_x', ['multitest_score', 'multitest_score'], ['score'], [int], # [('extern', ut.load_data)],
#configclass=DummyIndexerConfig,
)
def multitest_score_x(depc, *args, **kwargs):
raise NotImplementedError('hack')
# REGISTER MATCHING ALGORITHMS
@depc.register_preproc(tablename='neighbs', colnames=['qx2_idx', 'qx2_dist'],
coltypes=[np.ndarray, np.ndarray],
parents=['keypoint', 'fgweight', 'nnindexer', 'nnindexer'])
def neighbs(depc, *args, **kwargs):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
#dummy_preproc_kpts
for qaid in zip(args):
yield np.array([qaid]), np.array([qaid])
@depc.register_preproc(tablename='neighbs_score', colnames=['qx2_dist'],
coltypes=[np.ndarray],
parents=['neighbs'])
def neighbs_score(depc, *args, **kwargs):
"""
CommandLine:
python -m dtool.base --exec-VsManySimilarityRequest
"""
raise NotImplementedError('hack')
@depc.register_preproc(
'vsone', [dummy_root, dummy_root],
['score', 'match_obj', 'fm'],
[float, DummyVsOneMatch, np.ndarray],
requestclass=DummyVsOneRequest,
configclass=DummyVsOneConfig,
chunksize=2
)
def vsone_matching(depc, qaids, daids, config):
"""
CommandLine:
python -m dtool.base --exec-VsOneSimilarityRequest
"""
print('RUNNING DUMMY VSONE ALGO')
for qaid, daid in zip(qaids, daids):
match = DummyVsOneMatch()
match.qaid = qaid
match.daid = daid
match.fm = np.array([[1, 2], [3, 4]])
score = match.score = qaid + daid
yield (score, match, match.fm)
# table = depc['spam']
# print(ut.repr2(table.get_addtable_kw(), nl=2))
depc.initialize()
# table.print_schemadef()
# print(table.db.get_schema_current_autogeneration_str())
return depc
