def sequential_feat_load(feat_cfg, feat_fpath_list):
kpts_list = []
desc_list = []
# Debug loading (seems to use lots of memory)
print('\n')
try:
nFeats = len(feat_fpath_list)
prog_label = '[fc2] Loading feature: '
mark_progress, end_progress = helpers.progress_func(nFeats, prog_label)
for count, feat_path in enumerate(feat_fpath_list):
try:
npz = np.load(feat_path, mmap_mode=None)
except IOError:
print('\n')
helpers.checkpath(feat_path, verbose=True)
print('IOError on feat_path=%r' % feat_path)
raise
kpts = npz['arr_0']
desc = npz['arr_1']
npz.close()
kpts_list.append(kpts)
desc_list.append(desc)
mark_progress(count)
end_progress()
print('[fc2] Finished load of individual kpts and desc')
except MemoryError:
print('\n------------')
print('[fc2] Out of memory')
print('[fc2] Trying to read: %r' % feat_path)
print('[fc2] len(kpts_list) = %d' % len(kpts_list))
print('[fc2] len(desc_list) = %d' % len(desc_list))
raise
if feat_cfg.whiten:
desc_list = whiten_features(desc_list)
return kpts_list, desc_list
def progress_func(maxval=0):
mark_progress, end_progress = helpers.progress_func(maxval,
mark_after=MARK_AFTER,
progress_type='simple')
#if maxval > MARK_AFTER:
#print('')
return mark_progress, end_progress
def delete_suffixed_images(hs, back):
remove_cands = []
gx2_gname = hs.tables.gx2_gname
# Check to see if the image is a copy of another
for gx, gname in enumerate(gx2_gname):
name, ext = splitext(gname)
components = name.split('_')
if len(components) == 2:
orig_name, copynum = components
orig_gname = orig_name + ext
copyof = np.where(gx2_gname == orig_gname)[0]
if len(copyof) > 0:
remove_cands.append((gx, copyof))
# Make sure the images are actually duplicates
remove_gxs = []
orphaned_cxs = []
for copy_gx, orig_gx in remove_cands:
if isinstance(orig_gx, np.ndarray):
orig_gx = orig_gx[0]
if np.all(hs.gx2_image(copy_gx) == hs.gx2_image(orig_gx)):
print('[script] duplicate found copy_gx=%r, orig_gx=%r' % (copy_gx, orig_gx))
remove_gxs.append(copy_gx)
copy_cxs = hs.gx2_cxs(copy_gx)
orphaned_cxs.append((copy_cxs, orig_gx))
# THESE ACTUALLY MODIFY THE DATABASE
# Move all chips to the original
for cx_list, orig_gx in orphaned_cxs:
for cx in cx_list:
print('[script] relocate cx=%r to gx=%r' % (cx, orig_gx))
hs.tables.cx2_gx[cx] = orig_gx
# Move deleted images into the trash
trash_dir = join(hs.dirs.db_dir, 'deleted-images')
src_list = hs.gx2_gname(remove_gxs, full=True)
dst_list = hs.gx2_gname(remove_gxs, prefix=trash_dir)
helpers.ensuredir(trash_dir)
move_list = zip(src_list, dst_list)
mark_progress, end_prog = helpers.progress_func(len(move_list), lbl='Trashing Image')
for count, (src, dst) in enumerate(move_list):
shutil.move(src, dst)
mark_progress(count)
end_prog()
for gx in remove_gxs:
print('[script] remove gx=%r' % (gx,))
hs.tables.gx2_gname[gx] = ''
# Update and save
hs.update_samples()
back.populate_image_table()
hs.save_database()
return locals()
def make_feature_graph(qreq, qcx2_res, use_networkx=True):
# Make a graph between the chips
cxfx2_ax = {(cx, fx): ax for ax, (cx, fx) in get_cxfx_enum(qreq)}
def w_edge(cx1, cx2, fx1, fx2, score, rank):
ax1 = cxfx2_ax[(cx1, fx1)]
ax2 = cxfx2_ax[(cx2, fx2)]
attr_dict = {'score': score, 'rank': rank}
return (ax1, ax2, attr_dict)
nodes = [(ax, {'fx': fx, 'cx': cx}) for ax, (cx, fx) in get_cxfx_enum(qreq)]
weighted_edges = [w_edge(cx1, cx2, fx1, fx2, score, rank)
for (cx1, res) in qcx2_res.iteritems()
for (cx2, (fx1, fx2), score, rank) in get_fmatch_iter(res)
if score > 0]
if use_networkx:
graph = netx.DiGraph()
graph.add_nodes_from(nodes)
graph.add_edges_from(weighted_edges)
else:
vx2_ax = cxfx2_ax.values()
import graph_tool
graph = graph_tool.Graph(g=None, directed=True, prune=False, vorder=None)
vertex_list = graph.add_vertex(n=len(nodes))
v_fx = graph.new_vertex_property("int")
v_cx = graph.new_vertex_property("int")
e_score = graph.new_edge_property("float")
e_rank = graph.new_edge_property("int")
for v, (ax, vprops) in zip(vertex_list, nodes):
v_cx[v] = int(vprops['cx'])
v_fx[v] = int(vprops['fx'])
mark_prog, end_prog = util.progress_func(len(weighted_edges))
count = 0
for ax1, ax2, prop_dict in weighted_edges:
mark_prog(count)
count += 1
vx1 = vx2_ax.index(ax1)
vx2 = vx2_ax.index(ax2)
v1 = graph.vertex(vx1)
v2 = graph.vertex(vx2)
e = graph.add_edge(v1, v2)
e_score[e] = float(prop_dict['score'])
e_rank[e] = int(prop_dict['rank'])
mark_prog(count)
end_prog()
#import graph_tool.draw
graph.save('test_graph.dot')
return graph
def add_images(hs, fpath_list, move_images=True):
nImages = len(fpath_list)
print('[hs.add_imgs] adding %d images' % nImages)
img_dir = hs.dirs.img_dir
copy_list = []
helpers.ensurepath(img_dir)
if move_images:
# Build lists of where the new images will be
fpath_list2 = [
join(img_dir,
split(fpath)[1]) for fpath in fpath_list
]
copy_iter = izip(fpath_list, fpath_list2)
copy_list = [(src, dst) for src, dst in copy_iter
if not exists(dst)]
nExist = len(fpath_list2) - len(copy_list)
print('[hs] copying %d images' % len(copy_list))
print('[hs] %d images already exist' % nExist)
# RCOS TODO: Copying like this should be a helper function.
# It appears in multiple places
# Also there should be the option of parallelization? IDK, these are
# disk writes, but it still might help.
mark_progress, end_progress = helpers.progress_func(
len(copy_list), lbl='Copying Image')
for count, (src, dst) in enumerate(copy_list):
shutil.copy(src, dst)
mark_progress(count)
end_progress()
else:
print('[hs.add_imgs] using original image paths')
fpath_list2 = fpath_list
# Get location of the new images relative to the image dir
gx2_gname = hs.tables.gx2_gname.tolist()
gx2_aif = hs.tables.gx2_aif.tolist()
relpath_list = [relpath(fpath, img_dir) for fpath in fpath_list2]
current_gname_set = set(gx2_gname)
# Check to make sure the gnames are not currently indexed
new_gnames = [
gname for gname in relpath_list if not gname in current_gname_set
]
new_aifs = [False] * len(new_gnames)
nNewImages = len(new_gnames)
nIndexed = nImages - nNewImages
print('[hs.add_imgs] new_gnames:\n' + '\n'.join(new_gnames))
print('[hs.add_imgs] %d images already indexed.' % nIndexed)
print('[hs.add_imgs] Added %d new images.' % nIndexed)
# Append the new gnames to the hotspotter table
hs.tables.gx2_gname = np.array(gx2_gname + new_gnames)
hs.tables.gx2_aif = np.array(gx2_aif + new_aifs)
hs.update_samples()
return nNewImages
def add_images(hs, fpath_list, move_images=True):
nImages = len(fpath_list)
print('[hs.add_imgs] adding %d images' % nImages)
img_dir = hs.dirs.img_dir
copy_list = []
helpers.ensurepath(img_dir)
if move_images:
# Build lists of where the new images will be
fpath_list2 = [join(img_dir, split(fpath)[1]) for fpath in fpath_list]
copy_iter = izip(fpath_list, fpath_list2)
copy_list = [(src, dst) for src, dst in copy_iter if not exists(dst)]
nExist = len(fpath_list2) - len(copy_list)
print('[hs] copying %d images' % len(copy_list))
print('[hs] %d images already exist' % nExist)
# RCOS TODO: Copying like this should be a helper function.
# It appears in multiple places
# Also there should be the option of parallelization? IDK, these are
# disk writes, but it still might help.
mark_progress, end_progress = helpers.progress_func(len(copy_list), lbl='Copying Image')
for count, (src, dst) in enumerate(copy_list):
shutil.copy(src, dst)
mark_progress(count)
end_progress()
else:
print('[hs.add_imgs] using original image paths')
fpath_list2 = fpath_list
# Get location of the new images relative to the image dir
gx2_gname = hs.tables.gx2_gname.tolist()
gx2_aif = hs.tables.gx2_aif.tolist()
relpath_list = [relpath(fpath, img_dir) for fpath in fpath_list2]
current_gname_set = set(gx2_gname)
# Check to make sure the gnames are not currently indexed
new_gnames = [gname for gname in relpath_list if not gname in current_gname_set]
new_aifs = [False] * len(new_gnames)
nNewImages = len(new_gnames)
nIndexed = nImages - nNewImages
print('[hs.add_imgs] new_gnames:\n' + '\n'.join(new_gnames))
print('[hs.add_imgs] %d images already indexed.' % nIndexed)
print('[hs.add_imgs] Added %d new images.' % nIndexed)
# Append the new gnames to the hotspotter table
hs.tables.gx2_gname = np.array(gx2_gname + new_gnames)
hs.tables.gx2_aif = np.array(gx2_aif + new_aifs)
hs.update_samples()
return nNewImages
def _delete_image(hs, gx_list):
for gx in gx_list:
cx_list = hs.gx2_cxs(gx)
for cx in cx_list:
hs.delete_chip(cx, resample=False)
hs.tables.gx2_gname[gx] = ''
trash_dir = join(hs.dirs.db_dir, 'deleted-images')
src_list = hs.gx2_gname(gx_list, full=True)
dst_list = hs.gx2_gname(gx_list, prefix=trash_dir)
helpers.ensuredir(trash_dir)
# Move deleted images into the trash
move_list = zip(src_list, dst_list)
mark_progress, end_progress = helpers.progress_func(len(move_list), lbl='Trashing Image')
for count, (src, dst) in enumerate(move_list):
shutil.move(src, dst)
mark_progress(count)
end_progress()
hs.update_samples()
hs.save_database()
def score_chipmatch_coverage(hs, qcx, chipmatch, qreq, method=0):
prescore_method = 'csum'
nShortlist = 100
dcxs_ = set(qreq._dcxs)
(cx2_fm, cx2_fs, cx2_fk) = chipmatch
cx2_prescore = mf.score_chipmatch(hs, qcx, chipmatch, prescore_method, qreq)
topx2_cx = cx2_prescore.argsort()[::-1] # Only allow indexed cxs to be in the top results
topx2_cx = [cx for cx in iter(topx2_cx) if cx in dcxs_]
nRerank = min(len(topx2_cx), nShortlist)
cx2_score = [0 for _ in xrange(len(cx2_fm))]
mark_progress, end_progress = util.progress_func(nRerank, flush_after=10,
lbl='[cov] Compute coverage')
for topx in xrange(nRerank):
mark_progress(topx)
cx2 = topx2_cx[topx]
fm = cx2_fm[cx2]
fs = cx2_fs[cx2]
covscore = get_match_coverage_score(hs, qcx, cx2, fm, fs, method=method)
cx2_score[cx2] = covscore
end_progress()
return cx2_score
def _delete_image(hs, gx_list):
for gx in gx_list:
cx_list = hs.gx2_cxs(gx)
for cx in cx_list:
hs.delete_chip(cx, resample=False)
hs.tables.gx2_gname[gx] = ''
trash_dir = join(hs.dirs.db_dir, 'deleted-images')
src_list = hs.gx2_gname(gx_list, full=True)
dst_list = hs.gx2_gname(gx_list, prefix=trash_dir)
helpers.ensuredir(trash_dir)
# Move deleted images into the trash
move_list = zip(src_list, dst_list)
mark_progress, end_progress = helpers.progress_func(len(move_list),
lbl='Trashing Image')
for count, (src, dst) in enumerate(move_list):
shutil.move(src, dst)
mark_progress(count)
end_progress()
hs.update_samples()
hs.save_database()
def export_subdatabase(hs, gx_list, new_dbdir):
# New database dirs
new_imgdir = join(new_dbdir, ld2.RDIR_IMG)
new_internal = join(new_dbdir, ld2.RDIR_INTERNAL)
print('[scripts] Exporting into %r' % new_dbdir)
# Ensure new database
helpers.ensuredir(new_dbdir)
helpers.ensuredir(new_imgdir)
helpers.ensuredir(new_internal)
gname_list = hs.gx2_gname(gx_list)
src_gname_list = hs.gx2_gname(gx_list, full=True)
dst_gname_list = map(lambda gname: join(new_imgdir, gname), gname_list)
copy_list = [(src, dst) for (src, dst) in zip(src_gname_list, dst_gname_list)]
mark_progress, end_prog = helpers.progress_func(len(copy_list), lbl='Copy Images')
for count, (src, dst) in enumerate(copy_list):
shutil.copy(src, dst)
mark_progress(count)
end_prog()
cx_list = [cx for cxs in hs.gx2_cxs(gx_list) for cx in cxs.tolist()]
nx_list = np.unique(hs.tables.cx2_nx[cx_list])
image_table = ld2.make_image_csv2(hs, gx_list)
chip_table = ld2.make_chip_csv2(hs, cx_list)
name_table = ld2.make_name_csv2(hs, nx_list)
# csv filenames
chip_table_fpath = join(new_internal, ld2.CHIP_TABLE_FNAME)
name_table_fpath = join(new_internal, ld2.NAME_TABLE_FNAME)
image_table_fpath = join(new_internal, ld2.IMAGE_TABLE_FNAME)
# write csv files
helpers.write_to(chip_table_fpath, chip_table)
helpers.write_to(name_table_fpath, name_table)
helpers.write_to(image_table_fpath, image_table)
return locals()
def draw_images_at_positions(img_list, pos_list):
print('[encounter] drawing %d images' % len(img_list))
# Thumb stack
ax = df2.gca()
fig = df2.gcf()
trans = ax.transData.transform
trans2 = fig.transFigure.inverted().transform
mark_progress, end_progress = util.progress_func(len(pos_list), lbl='drawing img')
for ix, ((x, y), img) in enumerate(izip(pos_list, img_list)):
mark_progress(ix)
xx, yy = trans((x, y)) # figure coordinates
xa, ya = trans2((xx, yy)) # axes coordinates
#
width, height = img.shape[0:2]
tlx = xa - (width / 2.0)
tly = ya - (height / 2.0)
img_bbox = [tlx, tly, width, height]
# Make new axis for the image
img_ax = df2.plt.axes(img_bbox)
img_ax.imshow(img)
img_ax.set_aspect('equal')
img_ax.axis('off')
end_progress()
def warp_srcimg_to_kpts(fx2_kp, srcimg, chip_shape, fx2_score=None, **kwargs):
if len(fx2_kp) == 0:
return None
if fx2_score is None:
fx2_score = np.ones(len(fx2_kp))
scale_factor = kwargs.get('scale_Factor', SCALE_FACTOR_DEFAULT)
# Build destination image
(h, w) = map(int, (chip_shape[0] * scale_factor, chip_shape[1] * scale_factor))
dstimg = np.zeros((h, w), dtype=np.float32)
dst_copy = dstimg.copy()
src_shape = srcimg.shape
# Build keypoint transforms
fx2_M = build_transforms(fx2_kp, (h, w), src_shape, scale_factor)
# cv2 warp flags
dsize = (w, h)
flags = cv2.INTER_LINEAR # cv2.INTER_LANCZOS4
boderMode = cv2.BORDER_CONSTANT
# mark prooress
mark_progress, end_progress = util.progress_func(len(fx2_M),
flush_after=20,
mark_after=1000,
lbl='coverage warp ')
# For each keypoint warp a gaussian scaled by the feature score
# into the image
count = 0
for count, (M, score) in enumerate(izip(fx2_M, fx2_score)):
mark_progress(count)
warped = cv2.warpAffine(srcimg * score, M, dsize,
dst=dst_copy,
flags=flags, borderMode=boderMode,
borderValue=0).T
catmat = np.dstack((warped.T, dstimg))
dstimg = catmat.max(axis=2)
mark_progress(count)
end_progress()
return dstimg
def progress_func(maxval=0):
mark_progress, end_progress = helpers.progress_func(maxval, mark_after=MARK_AFTER, progress_type='simple')
#if maxval > MARK_AFTER:
#print('')
return mark_progress, end_progress