def main():
parser = argparse.ArgumentParser(
description='perform PCA on model features',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input')
parser.add_argument('output')
parser.add_argument('-d',
'--dim',
type=int,
required=True,
help='PCA dimension')
parser.add_argument('--nr_worker',
type=int,
default=4,
help='number of workers')
parser.add_argument('--gpus', default='0,1,2,3', help='gpus to use')
args = parser.parse_args()
ftr = serial.load(args.input, np.ndarray)
logger.info('input feature shape: {}'.format(ftr.shape))
param = ISAParam(in_dim=ftr.shape[1], subspace_size=1, hid_dim=args.dim)
isa = ISA(param, ftr.T, args.nr_worker, map(int, args.gpus.split(',')))
mdl = isa.get_model_pcaonly()
serial.dump({'W': mdl.coeff, 'b': mdl.bias}, args.output)
def __init__(self, args):
self._args = args
self._rng = np.random.RandomState(args.seed)
ref_ftr, ref_ftr_idx = self._load_ref_ftr()
test_pack = serial.load(args.test, ModelEvalOutput)
test_ftr = test_pack.ftr[
:, ::args.test_downsample, ::args.test_downsample,
::args.test_downsample]
ftr_dim = ref_ftr.shape[0]
assert ftr_dim == test_ftr.shape[0]
test_ftr_shape = test_ftr.shape[1:]
ref_ftr = ref_ftr.reshape(ftr_dim, -1).T
test_ftr = test_ftr.reshape(ftr_dim, -1).T
raw_idx, match_dist = self._get_match_idx_and_dist(ref_ftr, test_ftr)
match_dist = np.asarray(match_dist, dtype=np.float32)
match_idx = [self._cvt_index_to_coord(i, test_ftr_shape)
for i in raw_idx]
match_idx = np.asarray(match_idx, dtype=np.int32).reshape(
ref_ftr.shape[0], 3)
match_idx *= args.test_downsample
match_idx -= test_pack.img2ftr_offset
serial.dump(
PointMatchResult(
ref_idx=ref_ftr_idx,
idx=match_idx, dist=match_dist, img_shape=test_pack.img.shape,
args=args),
args.output, use_pickle=True)
def crop(args):
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
helper = CropPatchHelper(args.patch_size,
0,
rng=np.random.RandomState(args.seed))
output = np.empty((args.patch_size**3, len(flist) * args.patch_per_img),
dtype='float32')
logger.info('data size: {:.3f} GiB'.format(output.size * 4 / 1024.0**3))
prog = ProgressReporter('crop', output.shape[1])
output_idx = 0
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
it = helper(data)
for i in range(args.patch_per_img):
output[:, output_idx] = next(it).flatten()
output_idx += 1
prog.trigger()
prog.finish()
serial.dump(output, args.output)
def main():
parser = argparse.ArgumentParser(
description='crop 3D image at given position',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--xmin', type=int, default=0)
parser.add_argument('--xmax', type=int)
parser.add_argument('--ymin', type=int, default=0)
parser.add_argument('--ymax', type=int)
parser.add_argument('--zmin', type=int, default=0)
parser.add_argument('--zmax', type=int)
parser.add_argument('input')
parser.add_argument('output')
args = parser.parse_args()
img = serial.load(args.input)
assert img.ndim == 3
if args.xmax is None:
args.xmax = img.shape[0]
if args.ymax is None:
args.ymax = img.shape[1]
if args.zmax is None:
args.zmax = img.shape[2]
img = img[args.xmin:args.xmax, args.ymin:args.ymax, args.zmin:args.zmax]
serial.dump(img, args.output)
def __init__(self, args):
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
out_patch_tot_size = self._init_l0(args)
self._output = np.empty(
(out_patch_tot_size, len(flist) * args.patch_per_img),
dtype='float32')
logger.info('data size: {:.3f} GiB'.format(self._output.size * 4 /
1024.0**3))
self._prog = ProgressReporter('crop', self.nr_patch)
self._helper = CropPatchHelper(args.patch_size,
0,
rng=np.random.RandomState(args.seed))
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
self._work_single(data, args)
self._prog.finish()
serial.dump(self._output, args.output)
def main():
parser = argparse.ArgumentParser(
description='perform PCA on model features',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input')
parser.add_argument('output')
parser.add_argument('-d', '--dim', type=int, required=True,
help='PCA dimension')
parser.add_argument('--nr_worker', type=int, default=4,
help='number of workers')
parser.add_argument('--gpus', default='0,1,2,3',
help='gpus to use')
args = parser.parse_args()
ftr = serial.load(args.input, np.ndarray)
logger.info('input feature shape: {}'.format(ftr.shape))
param = ISAParam(in_dim=ftr.shape[1], subspace_size=1, hid_dim=args.dim)
isa = ISA(param, ftr.T, args.nr_worker, map(int, args.gpus.split(',')))
mdl = isa.get_model_pcaonly()
serial.dump(
{'W': mdl.coeff,
'b': mdl.bias},
args.output)
def __init__(self, args):
self._args = args
self._rng = np.random.RandomState(args.seed)
ref_ftr, ref_ftr_idx = self._load_ref_ftr()
test_pack = serial.load(args.test, ModelEvalOutput)
test_ftr = test_pack.ftr[:, ::args.test_downsample, ::args.
test_downsample, ::args.test_downsample]
ftr_dim = ref_ftr.shape[0]
assert ftr_dim == test_ftr.shape[0]
test_ftr_shape = test_ftr.shape[1:]
ref_ftr = ref_ftr.reshape(ftr_dim, -1).T
test_ftr = test_ftr.reshape(ftr_dim, -1).T
raw_idx, match_dist = self._get_match_idx_and_dist(ref_ftr, test_ftr)
match_dist = np.asarray(match_dist, dtype=np.float32)
match_idx = [
self._cvt_index_to_coord(i, test_ftr_shape) for i in raw_idx
]
match_idx = np.asarray(match_idx,
dtype=np.int32).reshape(ref_ftr.shape[0], 3)
match_idx *= args.test_downsample
match_idx -= test_pack.img2ftr_offset
serial.dump(PointMatchResult(ref_idx=ref_ftr_idx,
idx=match_idx,
dist=match_dist,
img_shape=test_pack.img.shape,
args=args),
args.output,
use_pickle=True)
def main():
parser = argparse.ArgumentParser(
description='convert ISA model to convolution and apply to data',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--l0', required=True, help='layer0 model')
parser.add_argument('--l1', required=True, help='layer1 model')
parser.add_argument('--check',
type=int,
help='number of patches to check fprop output')
parser.add_argument('input')
parser.add_argument('output')
args = parser.parse_args()
layer0, layer1 = map(serial.load, (args.l0, args.l1))
fprop = make_fprop(layer0, layer1)
x = serial.load(args.input)
logger.info('input shape: {}'.format(x.shape))
y = fprop(x)
logger.info('output shape: {}'.format(y.shape))
opath = args.output
if '.' in opath and ('/' not in opath or '.' in opath[opath.rfind('/'):]):
opath = opath[:opath.rfind('.')] + '.pkl'
else:
opath += '.pkl'
serial.dump(ModelEvalOutput(img=x, ftr=y), opath)
logger.info('result wrote to {}'.format(opath))
if args.check:
check_output(x, y, layer0, layer1, args.check)
def main():
parser = argparse.ArgumentParser(
description='convert ISA model to convolution and apply to data',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--l0', required=True, help='layer0 model')
parser.add_argument('--l1', required=True, help='layer1 model')
parser.add_argument('--check', type=int,
help='number of patches to check fprop output')
parser.add_argument('input')
parser.add_argument('output')
args = parser.parse_args()
layer0, layer1 = map(serial.load, (args.l0, args.l1))
fprop = make_fprop(layer0, layer1)
x = serial.load(args.input)
logger.info('input shape: {}'.format(x.shape))
y = fprop(x)
logger.info('output shape: {}'.format(y.shape))
opath = args.output
if '.' in opath and ('/' not in opath or '.' in opath[opath.rfind('/'):]):
opath = opath[:opath.rfind('.')] + '.pkl'
else:
opath += '.pkl'
serial.dump(ModelEvalOutput(img=x, ftr=y), opath)
logger.info('result wrote to {}'.format(opath))
if args.check:
check_output(x, y, layer0, layer1, args.check)
def main():
parser = argparse.ArgumentParser(
description='crop 3D image at given position',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--xmin', type=int, default=0)
parser.add_argument('--xmax', type=int)
parser.add_argument('--ymin', type=int, default=0)
parser.add_argument('--ymax', type=int)
parser.add_argument('--zmin', type=int, default=0)
parser.add_argument('--zmax', type=int)
parser.add_argument('input')
parser.add_argument('output')
args = parser.parse_args()
img = serial.load(args.input)
assert img.ndim == 3
if args.xmax is None:
args.xmax = img.shape[0]
if args.ymax is None:
args.ymax = img.shape[1]
if args.zmax is None:
args.zmax = img.shape[2]
img = img[args.xmin:args.xmax, args.ymin:args.ymax, args.zmin:args.zmax]
serial.dump(img, args.output)
def crop(args):
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
helper = CropPatchHelper(
args.patch_size, 0, rng=np.random.RandomState(args.seed))
output = np.empty(
(args.patch_size**3, len(flist) * args.patch_per_img),
dtype='float32')
logger.info('data size: {:.3f} GiB'.format(
output.size * 4 / 1024.0**3))
prog = ProgressReporter('crop', output.shape[1])
output_idx = 0
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
it = helper(data)
for i in range(args.patch_per_img):
output[:, output_idx] = next(it).flatten()
output_idx += 1
prog.trigger()
prog.finish()
serial.dump(output, args.output)
def main():
parser = argparse.ArgumentParser(
description='calculate distance to mask border',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input', help='input mask image')
parser.add_argument('output', help='border dist output')
args = parser.parse_args()
inp = serial.load(args.input)
mask = (inp >= (inp.max() / 2)).astype(np.int32)
with timed_operation('calc_border_dist: {}'.format(mask.shape)):
output = calc_border_dist(mask)
serial.dump(output, args.output)
def main():
parser = argparse.ArgumentParser(
description='pack image and feature pairs for show_dist',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('img')
parser.add_argument('feature')
parser.add_argument('output')
args = parser.parse_args()
img = serial.load(args.img)
ftr = serial.load(args.feature)
assert img.ndim == 3 and ftr.ndim == 4
serial.dump({'img': img, 'ftr': ftr}, args.output)
def main():
parser = argparse.ArgumentParser(
description='pack image and feature pairs for show_dist',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('img')
parser.add_argument('feature')
parser.add_argument('output')
args = parser.parse_args()
img = serial.load(args.img)
ftr = serial.load(args.feature)
assert img.ndim == 3 and ftr.ndim == 4
serial.dump({'img': img, 'ftr': ftr}, args.output)
def main():
parser = argparse.ArgumentParser(
description='visualize model',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('model')
parser.add_argument('output')
parser.add_argument('--in_chl', type=int,
help='specify model input channels')
args = parser.parse_args()
model = serial.load(args.model, ISAModel)
if args.in_chl:
model.in_chl = args.in_chl
data = model.get_conv_coeff()
serial.dump(data, args.output, use_pickle=True)
def main():
parser = argparse.ArgumentParser(
description='extract matched patches',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--border_dir',
default=os.path.abspath(
os.path.join(os.path.dirname(__file__),
'../../sliver07/border-dist')),
help='directory that store the border dist files')
parser.add_argument('--img_dir',
default=os.path.abspath(
os.path.join(os.path.dirname(__file__),
'../../sliver07/train-cropped')),
help='directory that store original image files')
parser.add_argument('-o', '--output', required=True)
parser.add_argument('--out_bd_dist', help='output border dist')
parser.add_argument('--dist_min',
type=int,
default=-1,
help='minimum dist to be considered as hit')
parser.add_argument('--dist_max',
type=int,
default=1,
help='maximum dist to be considered as hit')
parser.add_argument('--patch_radius',
type=int,
default=20,
help='radius for patch to be extracted')
parser.add_argument('--highlight_radius',
type=int,
default=10,
help='radius for patch to be extracted')
parser.add_argument('--nr_keep',
type=int,
default=100,
help='number of results to be kept')
parser.add_argument('input', nargs='+')
args = parser.parse_args()
loader = PatchLoader(args)
for i in args.input:
logger.info('loading {}'.format(i))
loader.feed(i)
logger.info('write result to {}'.format(args.output))
serial.dump(loader.get_result(), args.output)
if args.out_bd_dist:
logger.info('write border dist to {}'.format(args.out_bd_dist))
serial.dump(loader.get_result_dist(), args.out_bd_dist)
def main():
parser = argparse.ArgumentParser(
description='train ISA',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--subspace_size',
type=int,
default=2,
help='number of features in each subspace')
parser.add_argument('--out_dim',
type=int,
default=150,
help='output dimension (i.e. number of subspaces)')
parser.add_argument('--nr_worker', type=int, default=4)
parser.add_argument('--gpus',
default='0,1,2,3',
help='list of gpus to use')
parser.add_argument('--dump_iter',
type=int,
default=10,
help='number of iters between model dump')
parser.add_argument('--learning_rate', type=float, default=2)
parser.add_argument('data')
parser.add_argument('output')
args = parser.parse_args()
data = serial.load(args.data, np.ndarray)
param = ISAParam(in_dim=data.shape[0],
subspace_size=args.subspace_size,
out_dim=args.out_dim)
isa = ISA(param,
data,
nr_worker=args.nr_worker,
gpu_list=map(int, args.gpus.split(',')))
iter_num = 0
while True:
monitor = isa.perform_iter(args.learning_rate)
msg = 'train iter {}\n'.format(iter_num)
for k, v in monitor.iteritems():
msg += '{}: {}\n'.format(k, v)
logger.info(msg[:-1])
if iter_num % args.dump_iter == 0:
model = isa.get_model()
model.monitor = monitor
serial.dump(model, args.output, use_pickle=True)
iter_num += 1
def crop(args):
osize = int(args.patch_size * args.bg_scale)
if (osize - args.patch_size) % 2:
osize += 1
helper = CropPatchHelper(
args.patch_size, (osize - args.patch_size) / 2,
rng=np.random.RandomState(args.seed))
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
data_shape = (len(flist) * args.patch_per_img, osize, osize, osize)
logger.info('data: shape={} size={:.3f}GiB'.format(
data_shape, np.prod(data_shape) * 4 / 1024.0**3))
output = np.empty(data_shape, dtype='float32')
prog = ProgressReporter('crop', output.shape[0])
output_idx = 0
mask = None
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
if args.masked:
mask = serial.load(os.path.join(
basedir, fpath.replace('orig', 'mask')))
it = helper(data, mask)
for i in range(args.patch_per_img):
output[output_idx] = next(it)
output_idx += 1
prog.trigger()
prog.finish()
data = TrainingData(patch=output, args=args)
serial.dump(data, args.output)
def main():
parser = argparse.ArgumentParser(
description='train ISA',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--subspace_size', type=int, default=2,
help='number of features in each subspace')
parser.add_argument('--out_dim', type=int, default=150,
help='output dimension (i.e. number of subspaces)')
parser.add_argument('--nr_worker', type=int, default=4)
parser.add_argument('--gpus', default='0,1,2,3',
help='list of gpus to use')
parser.add_argument('--dump_iter', type=int, default=10,
help='number of iters between model dump')
parser.add_argument('--learning_rate', type=float, default=2)
parser.add_argument('data')
parser.add_argument('output')
args = parser.parse_args()
data = serial.load(args.data, np.ndarray)
param = ISAParam(
in_dim=data.shape[0], subspace_size=args.subspace_size,
out_dim=args.out_dim)
isa = ISA(param, data, nr_worker=args.nr_worker,
gpu_list=map(int, args.gpus.split(',')))
iter_num = 0
while True:
monitor = isa.perform_iter(args.learning_rate)
msg = 'train iter {}\n'.format(iter_num)
for k, v in monitor.iteritems():
msg += '{}: {}\n'.format(k, v)
logger.info(msg[:-1])
if iter_num % args.dump_iter == 0:
model = isa.get_model()
model.monitor = monitor
serial.dump(model, args.output, use_pickle=True)
iter_num += 1
def crop(args):
osize = int(args.patch_size * args.bg_scale)
if (osize - args.patch_size) % 2:
osize += 1
helper = CropPatchHelper(args.patch_size, (osize - args.patch_size) / 2,
rng=np.random.RandomState(args.seed))
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
data_shape = (len(flist) * args.patch_per_img, osize, osize, osize)
logger.info('data: shape={} size={:.3f}GiB'.format(
data_shape,
np.prod(data_shape) * 4 / 1024.0**3))
output = np.empty(data_shape, dtype='float32')
prog = ProgressReporter('crop', output.shape[0])
output_idx = 0
mask = None
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
if args.masked:
mask = serial.load(
os.path.join(basedir, fpath.replace('orig', 'mask')))
it = helper(data, mask)
for i in range(args.patch_per_img):
output[output_idx] = next(it)
output_idx += 1
prog.trigger()
prog.finish()
data = TrainingData(patch=output, args=args)
serial.dump(data, args.output)
def __init__(self, args):
basedir = os.path.dirname(args.imglist)
with open(args.imglist) as fin:
flist = fin.readlines()
out_patch_tot_size = self._init_l0(args)
self._output = np.empty(
(out_patch_tot_size, len(flist) * args.patch_per_img),
dtype='float32')
logger.info('data size: {:.3f} GiB'.format(
self._output.size * 4 / 1024.0**3))
self._prog = ProgressReporter('crop', self.nr_patch)
self._helper = CropPatchHelper(
args.patch_size, 0, rng=np.random.RandomState(args.seed))
for fpath in flist:
fpath = fpath.strip()
data = serial.load(os.path.join(basedir, fpath))
self._work_single(data, args)
self._prog.finish()
serial.dump(self._output, args.output)
def main():
parser = argparse.ArgumentParser(
description='view point match result',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input', nargs='+')
parser.add_argument('--radius',
type=int,
default=2,
help='radius of points drawn on image')
parser.add_argument('--mask', help='plot groundtruth mask')
parser.add_argument('--orig', help='plot original test image')
parser.add_argument('--is_roc_dist_dump',
action='store_true',
help='input file is ROC dist dump')
parser.add_argument('--border_dist_min',
type=int,
default=-1,
help='min border dist to be considered as matched')
parser.add_argument('--border_dist_max',
type=int,
default=1,
help='max border dist to be considered as matched')
parser.add_argument('--dist_thresh',
type=float,
default=float('inf'),
help='feature dist threshold')
parser.add_argument('-o', '--output', help='write final image to file')
args = parser.parse_args()
img = None
nr_pt_view = 0
if args.is_roc_dist_dump:
assert len(args.input) == 1
nr_matched = 0
tot_nr_point = 0
for i in args.input:
logger.info('load {}'.format(i))
pmtch_rst = serial.load(i, PointMatchResult)
img_shape = pmtch_rst.img_shape
if args.mask:
img_shape = (3, ) + img_shape
if img is None:
img = load_image(args, img_shape)
#view_3d_data_single(img)
else:
assert img.shape == img_shape
dist = -np.log(pmtch_rst.dist + 1e-5)
dist = (dist - dist.min()) / (dist.max() - dist.min() + 1e-20) * 0.5
dist += 0.5
dist *= img.max()
r = args.radius
for k in range(pmtch_rst.dist.shape[0]):
if pmtch_rst.dist[k] > args.dist_thresh:
continue
nr_pt_view += 1
val = dist[k]
x, y, z = pmtch_rst.idx[k]
x0, y0, z0 = [max(i - r, 0) for i in (x, y, z)]
x1, y1, z1 = [i + r for i in (x, y, z)]
if args.mask:
color = np.zeros([3, 1, 1, 1], dtype=img.dtype)
color[0] = val
if args.is_roc_dist_dump:
tot_nr_point += 1
geo_dist = pmtch_rst.geo_dist[k]
if (geo_dist >= args.border_dist_min
and geo_dist <= args.border_dist_max):
nr_matched += 1
color[:, 0, 0, 0] = (0, val, 0)
img[:, x0:x1, y0:y1, z0:z1] = color
else:
img[x0:x1, y0:y1, z0:z1] = val
logger.info('number of points: {}'.format(nr_pt_view))
if args.is_roc_dist_dump:
logger.info('match accuracy: {}; top ratio: {}'.format(
float(nr_matched) / tot_nr_point,
float(tot_nr_point) / pmtch_rst.dist.shape[0]))
if args.output:
serial.dump(img, args.output, use_pickle=True)
else:
view_3d_data_single(img)
def main():
parser = argparse.ArgumentParser(
description='test batched 3d affine transform',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-l', '--load',
help='load dumped argument')
parser.add_argument('-i', '--input',
help='batch image input')
parser.add_argument('--gen', action='store_true',
help='generate data for test')
parser.add_argument('--benchmark', action='store_true',
help='test kernel speed')
parser.add_argument('-b', '--batch', type=int, default=0,
help='batch number to view')
parser.add_argument('--border', type=int, default=40,
help='border to remove')
parser.add_argument('--angle', type=float, default=30,
help='max rotate angle in degrees')
parser.add_argument('-o', '--output', help='write output to file')
parser.add_argument('--identity', action='store_true',
help='use identity transform')
args = parser.parse_args()
add_axis = False
if args.gen:
inp = np.array([np.random.uniform(size=(4, 2, 3))] * 3)
affine_mat = np.eye(4)[:3]
oshp = inp.shape[1:]
elif args.input:
inp = serial.load(args.input)
if inp.ndim == 3:
add_axis = True
inp = np.expand_dims(inp, axis=0)
assert inp.ndim == 4
if args.identity:
affine_mat = np.tile(np.eye(4), (inp.shape[0], 1, 1))[:, :3]
oshp = inp.shape[1:]
else:
xl, yl, zl = inp.shape[1:]
affine_mat = RandomAffineMat(
inp.shape[0], center=(xl / 2, yl / 2, zl / 2),
min_angle=math.radians(-args.angle),
max_angle=math.radians(args.angle))()
affine_mat[:, :, 3] += args.border / 2
oshp = (xl - args.border, yl - args.border, zl - args.border)
if affine_mat.shape[0] == 1:
print 'affine mat:', affine_mat[0]
else:
assert args.load, 'must provide -i or -l'
inp, affine_mat, oshp, orig_out = serial.load(args.load)
out = batched_affine3d(inp, affine_mat, oshp)
if args.output:
out1 = out
if add_axis:
out1 = np.squeeze(out, axis=0)
serial.dump(out1, args.output, use_pickle=True)
if args.gen:
print out
elif not args.benchmark and not args.output:
view_3d_data_single(out[args.batch])
if args.benchmark:
inp = np.ascontiguousarray(inp).astype(np.float32)
affine_mat = np.ascontiguousarray(affine_mat).astype(np.float32)
nr_time = 10
t0 = time.time()
for i in range(nr_time):
out1 = batched_affine3d(inp, affine_mat, oshp)
assert np.max(np.abs(out - out1)) < 1e-9
dt = (time.time() - t0) / nr_time
print 'time={:.3f}ms GFlops={:.3f}'.format(
dt * 1000,
out.size * (28 + 21) / dt / 1e9)
def main():
parser = argparse.ArgumentParser(
description='test batched 3d affine transform',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-l', '--load', help='load dumped argument')
parser.add_argument('-i', '--input', help='batch image input')
parser.add_argument('--gen',
action='store_true',
help='generate data for test')
parser.add_argument('--benchmark',
action='store_true',
help='test kernel speed')
parser.add_argument('-b',
'--batch',
type=int,
default=0,
help='batch number to view')
parser.add_argument('--border',
type=int,
default=40,
help='border to remove')
parser.add_argument('--angle',
type=float,
default=30,
help='max rotate angle in degrees')
parser.add_argument('-o', '--output', help='write output to file')
parser.add_argument('--identity',
action='store_true',
help='use identity transform')
args = parser.parse_args()
add_axis = False
if args.gen:
inp = np.array([np.random.uniform(size=(4, 2, 3))] * 3)
affine_mat = np.eye(4)[:3]
oshp = inp.shape[1:]
elif args.input:
inp = serial.load(args.input)
if inp.ndim == 3:
add_axis = True
inp = np.expand_dims(inp, axis=0)
assert inp.ndim == 4
if args.identity:
affine_mat = np.tile(np.eye(4), (inp.shape[0], 1, 1))[:, :3]
oshp = inp.shape[1:]
else:
xl, yl, zl = inp.shape[1:]
affine_mat = RandomAffineMat(inp.shape[0],
center=(xl / 2, yl / 2, zl / 2),
min_angle=math.radians(-args.angle),
max_angle=math.radians(args.angle))()
affine_mat[:, :, 3] += args.border / 2
oshp = (xl - args.border, yl - args.border, zl - args.border)
if affine_mat.shape[0] == 1:
print 'affine mat:', affine_mat[0]
else:
assert args.load, 'must provide -i or -l'
inp, affine_mat, oshp, orig_out = serial.load(args.load)
out = batched_affine3d(inp, affine_mat, oshp)
if args.output:
out1 = out
if add_axis:
out1 = np.squeeze(out, axis=0)
serial.dump(out1, args.output, use_pickle=True)
if args.gen:
print out
elif not args.benchmark and not args.output:
view_3d_data_single(out[args.batch])
if args.benchmark:
inp = np.ascontiguousarray(inp).astype(np.float32)
affine_mat = np.ascontiguousarray(affine_mat).astype(np.float32)
nr_time = 10
t0 = time.time()
for i in range(nr_time):
out1 = batched_affine3d(inp, affine_mat, oshp)
assert np.max(np.abs(out - out1)) < 1e-9
dt = (time.time() - t0) / nr_time
print 'time={:.3f}ms GFlops={:.3f}'.format(
dt * 1000,
out.size * (28 + 21) / dt / 1e9)
def main():
parser = argparse.ArgumentParser(
description='view point match result',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('input', nargs='+')
parser.add_argument('--radius', type=int, default=2,
help='radius of points drawn on image')
parser.add_argument('--mask', help='plot groundtruth mask')
parser.add_argument('--orig', help='plot original test image')
parser.add_argument('--is_roc_dist_dump', action='store_true',
help='input file is ROC dist dump')
parser.add_argument('--border_dist_min', type=int, default=-1,
help='min border dist to be considered as matched')
parser.add_argument('--border_dist_max', type=int, default=1,
help='max border dist to be considered as matched')
parser.add_argument('--dist_thresh', type=float, default=float('inf'),
help='feature dist threshold')
parser.add_argument('-o', '--output', help='write final image to file')
args = parser.parse_args()
img = None
nr_pt_view = 0
if args.is_roc_dist_dump:
assert len(args.input) == 1
nr_matched = 0
tot_nr_point = 0
for i in args.input:
logger.info('load {}'.format(i))
pmtch_rst = serial.load(i, PointMatchResult)
img_shape = pmtch_rst.img_shape
if args.mask:
img_shape = (3, ) + img_shape
if img is None:
img = load_image(args, img_shape)
#view_3d_data_single(img)
else:
assert img.shape == img_shape
dist = -np.log(pmtch_rst.dist + 1e-5)
dist = (dist - dist.min()) / (dist.max() - dist.min() + 1e-20) * 0.5
dist += 0.5
dist *= img.max()
r = args.radius
for k in range(pmtch_rst.dist.shape[0]):
if pmtch_rst.dist[k] > args.dist_thresh:
continue
nr_pt_view += 1
val = dist[k]
x, y, z = pmtch_rst.idx[k]
x0, y0, z0 = [max(i - r, 0) for i in (x, y, z)]
x1, y1, z1 = [i + r for i in (x, y, z)]
if args.mask:
color = np.zeros([3, 1, 1, 1], dtype=img.dtype)
color[0] = val
if args.is_roc_dist_dump:
tot_nr_point += 1
geo_dist = pmtch_rst.geo_dist[k]
if (geo_dist >= args.border_dist_min and
geo_dist <= args.border_dist_max):
nr_matched += 1
color[:, 0, 0, 0] = (0, val, 0)
img[:, x0:x1, y0:y1, z0:z1] = color
else:
img[x0:x1, y0:y1, z0:z1] = val
logger.info('number of points: {}'.format(nr_pt_view))
if args.is_roc_dist_dump:
logger.info('match accuracy: {}; top ratio: {}'.format(
float(nr_matched) / tot_nr_point,
float(tot_nr_point) / pmtch_rst.dist.shape[0]))
if args.output:
serial.dump(img, args.output, use_pickle=True)
else:
view_3d_data_single(img)
