class PlenoptiCamTesterIllum(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(PlenoptiCamTesterIllum, self).__init__(*args, **kwargs)
def setUp(self):
# instantiate config and status objects
self.cfg = PlenopticamConfig()
self.cfg.default_values()
self.sta = PlenopticamStatus()
# enable options in config to cover more algorithms in tests
self.cfg.params[self.cfg.cal_meth] = 'grid-fit'
self.cfg.params[self.cfg.opt_vign] = True
self.cfg.params[self.cfg.opt_rota] = True
self.cfg.params[self.cfg.opt_refi] = True
self.cfg.params[self.cfg.opt_pflu] = True
self.cfg.params[self.cfg.opt_arti] = True
self.cfg.params[self.cfg.opt_lier] = True
self.cfg.params[self.cfg.opt_cont] = True
self.cfg.params[self.cfg.opt_awb_] = True
self.cfg.params[self.cfg.opt_sat_] = True
self.cfg.params[self.cfg.opt_dbug] = True
self.cfg.params[self.cfg.ran_refo] = [0, 1]
# compute 3x3 viewpoints only (to reduce computation time)
self.cfg.params[self.cfg.ptc_leng] = 3
# skip progress prints (prevent Travis from terminating due to reaching 4MB logfile size)
self.sta.prog_opt = False
# print current process message (to prevent Travis from stopping after 10 mins)
self.cfg.params[self.cfg.opt_prnt] = True
# retrieve Lytro Illum data
self.loader = DataDownloader(cfg=self.cfg, sta=self.sta)
self.fp = join(self.loader.root_path, 'examples', 'data')
archive_fn = join(self.fp, basename(self.loader.host_eu_url))
self.loader.download_data(
self.loader.host_eu_url,
fp=self.fp) if not exists(archive_fn) else None
self.loader.extract_archive(archive_fn)
def test_illum(self):
# use pre-loaded calibration dataset
wht_list = [
file for file in listdir(self.fp) if file.startswith('caldata')
]
lfp_list = [
file for file in listdir(self.fp) if file.endswith(('lfr', 'lfp'))
]
self.cfg.params[self.cfg.cal_path] = join(self.fp, wht_list[0])
for lfp_file in lfp_list:
self.cfg.params[self.cfg.lfp_path] = join(self.fp, lfp_file)
print('\nCompute image %s' %
basename(self.cfg.params[self.cfg.lfp_path]))
# decode light field image
obj = LfpReader(self.cfg, self.sta)
ret = obj.main()
# use third of original image size (to prevent Travis from stopping due to memory error)
crop_h, crop_w = obj.lfp_img.shape[0] // 3, obj.lfp_img.shape[
1] // 3
crop_h, crop_w = crop_h + crop_h % 2, crop_w + crop_w % 2 # use even number for correct Bayer arrangement
lfp_img = obj.lfp_img[crop_h:-crop_h, crop_w:-crop_w]
del obj
self.assertEqual(True, ret)
# create output data folder
mkdir_p(self.cfg.exp_path, self.cfg.params[self.cfg.opt_prnt])
if not self.cfg.cond_meta_file():
# automatic calibration data selection
obj = CaliFinder(self.cfg, self.sta)
ret = obj.main()
wht_img = obj.wht_bay[
crop_h:-crop_h,
crop_w:-crop_w] if obj.wht_bay is not None else obj.wht_bay
del obj
self.assertEqual(True, ret)
meta_cond = not (
exists(self.cfg.params[self.cfg.cal_meta]) and
self.cfg.params[self.cfg.cal_meta].lower().endswith('json'))
if meta_cond or self.cfg.params[self.cfg.opt_cali]:
# perform centroid calibration
obj = LfpCalibrator(wht_img, self.cfg, self.sta)
ret = obj.main()
self.cfg = obj.cfg
del obj
self.assertEqual(True, ret)
# load calibration data
self.cfg.load_cal_data()
# write centroids as png file
if wht_img is not None:
obj = CentroidDrawer(wht_img,
self.cfg.calibs[self.cfg.mic_list],
self.cfg)
ret = obj.write_centroids_img(fn='testcase_wht_img+mics.png')
del obj
self.assertEqual(True, ret)
# check if light field alignment has been done before
if self.cfg.cond_lfp_align():
# align light field
obj = LfpAligner(lfp_img, self.cfg, self.sta, wht_img)
ret = obj.main()
del obj
self.assertEqual(True, ret)
# load previously computed light field alignment
with open(join(self.cfg.exp_path, 'lfp_img_align.pkl'), 'rb') as f:
lfp_img_align = pickle.load(f)
# extract viewpoint data
CaliFinder(self.cfg).main()
obj = LfpExtractor(lfp_img_align, cfg=self.cfg, sta=self.sta)
ret = obj.main()
vp_img_arr = obj.vp_img_linear
del obj
self.assertEqual(True, ret)
# do refocusing
if self.cfg.params[self.cfg.opt_refo]:
obj = LfpRefocuser(vp_img_arr, cfg=self.cfg, sta=self.sta)
ret = obj.main()
del obj
self.assertEqual(True, ret)
return True
def test_all(self):
self.test_illum()
def main():
# program info
print("\nPlenoptiCam v%s \n" % __version__)
# create config object
cfg = PlenopticamConfig()
cfg.default_values()
# parse options
cfg = parse_options(sys.argv[1:], cfg)
# instantiate status object
sta = misc.PlenopticamStatus()
sta.bind_to_interrupt(sys.exit) # set interrupt
# force relative paths to be absolute
cfg.params[cfg.lfp_path] = os.path.abspath(cfg.params[cfg.lfp_path])
cfg.params[cfg.cal_path] = os.path.abspath(cfg.params[cfg.cal_path])
# collect light field image file name(s) based on provided path
if os.path.isdir(cfg.params[cfg.lfp_path]):
lfp_filenames = [
f for f in os.listdir(cfg.params[cfg.lfp_path])
if f.lower().endswith(SUPP_FILE_EXT)
]
cfg.params[cfg.lfp_path] = os.path.join(cfg.params[cfg.lfp_path],
'dummy.ext')
elif not os.path.isfile(cfg.params[cfg.lfp_path]):
lfp_filenames = [
misc.select_file(cfg.params[cfg.lfp_path],
'Select plenoptic image')
]
else:
lfp_filenames = [cfg.params[cfg.lfp_path]]
if not cfg.params[cfg.cal_path]:
# manual calibration data selection
sta.status_msg(
'\r Please select white image calibration source manually',
cfg.params[cfg.opt_prnt])
# open selection window (at current lfp file directory) to set calibration folder path
cfg.params[cfg.cal_path] = misc.select_file(
cfg.params[cfg.lfp_path], 'Select calibration image')
# provide number of found images to user
print("\n %s Image(s) found" % len(lfp_filenames))
# cancel if file paths not provided
sta.validate(checklist=lfp_filenames + [cfg.params[cfg.lfp_path]],
msg='Canceled due to missing image file path')
# iterate through light field image(s)
for lfp_filename in sorted(lfp_filenames):
# change path to next filename
cfg.params[cfg.lfp_path] = os.path.join(
os.path.dirname(cfg.params[cfg.lfp_path]), lfp_filename)
print(cfg.params[cfg.lfp_path])
sta.status_msg(msg='Process file ' + lfp_filename,
opt=cfg.params[cfg.opt_prnt])
# remove output folder if option is set
misc.rmdir_p(cfg.exp_path) if cfg.params[cfg.dir_remo] else None
try:
# decode light field image
lfp_obj = lfp_reader.LfpReader(cfg, sta)
lfp_obj.main()
lfp_img = lfp_obj.lfp_img
del lfp_obj
except Exception as e:
misc.PlenopticamError(e)
continue
# create output data folder
misc.mkdir_p(cfg.exp_path, cfg.params[cfg.opt_prnt])
if cfg.cond_auto_find():
# automatic calibration data selection
obj = lfp_calibrator.CaliFinder(cfg, sta)
obj.main()
wht_img = obj.wht_bay
del obj
else:
# load white image calibration file
wht_img = misc.load_img_file(cfg.params[cfg.cal_path])
# save settings configuration
cfg.save_params()
# perform calibration if previously computed calibration data does not exist
meta_cond = not (os.path.exists(cfg.params[cfg.cal_meta])
and cfg.params[cfg.cal_meta].lower().endswith('json'))
if meta_cond or cfg.params[cfg.opt_cali]:
# perform centroid calibration
cal_obj = lfp_calibrator.LfpCalibrator(wht_img, cfg, sta)
cal_obj.main()
cfg = cal_obj.cfg
del cal_obj
# load calibration data
cfg.load_cal_data()
# check if light field alignment has been done before
if cfg.cond_lfp_align():
# align light field
lfp_obj = lfp_aligner.LfpAligner(lfp_img, cfg, sta, wht_img)
lfp_obj.main()
lfp_obj = lfp_obj.lfp_img
del lfp_obj
# load previously computed light field alignment
with open(os.path.join(cfg.exp_path, 'lfp_img_align.pkl'), 'rb') as f:
lfp_img_align = pickle.load(f)
# extract viewpoint data
lfp_calibrator.CaliFinder(cfg).main()
obj = lfp_extractor.LfpExtractor(lfp_img_align, cfg=cfg, sta=sta)
obj.main()
vp_img_arr = obj.vp_img_arr
del obj
# do refocusing
if cfg.params[cfg.opt_refo]:
obj = lfp_refocuser.LfpRefocuser(vp_img_arr, cfg=cfg, sta=sta)
obj.main()
del obj
return True
def test_illum(self):
# instantiate config and status objects
cfg = PlenopticamConfig()
cfg.default_values()
sta = PlenopticamStatus()
# enable options in config to test more algorithms
cfg.params[cfg.cal_meth] = 'grid-fit'
cfg.params[cfg.opt_vign] = True
cfg.params[cfg.opt_rota] = True
cfg.params[cfg.opt_refi] = True
cfg.params[cfg.opt_pflu] = True
cfg.params[cfg.opt_arti] = True
cfg.params[cfg.opt_lier] = True
cfg.params[cfg.opt_cont] = True
cfg.params[cfg.opt_awb_] = True
cfg.params[cfg.opt_sat_] = True
cfg.params[cfg.ran_refo] = [0, 1]
# compute 3x3 viewpoints only (to reduce computation time)
cfg.params[cfg.ptc_leng] = 3
# skip progress prints (prevent Travis from terminating due to reaching 4MB logfile size)
sta.prog_opt = False
# print current process message (to prevent Travis from stopping after 10 mins)
cfg.params[cfg.opt_prnt] = True
# use pre-loaded calibration dataset
wht_list = [
file for file in os.listdir(self.fp) if file.startswith('caldata')
]
lfp_list = [
file for file in os.listdir(self.fp)
if file.endswith(('lfr', 'lfp'))
]
cfg.params[cfg.cal_path] = os.path.join(self.fp, wht_list[0])
for lfp_file in lfp_list:
cfg.params[cfg.lfp_path] = os.path.join(self.fp, lfp_file)
print('\nCompute image %s' %
os.path.basename(cfg.params[cfg.lfp_path]))
# decode light field image
obj = LfpReader(cfg, sta)
ret = obj.main()
# use third of original image size (to prevent Travis from stopping due to memory error)
crop_h, crop_w = obj.lfp_img.shape[0] // 3, obj.lfp_img.shape[
1] // 3
crop_h, crop_w = crop_h + crop_h % 2, crop_w + crop_w % 2 # use even number for correct Bayer arrangement
lfp_img = obj.lfp_img[crop_h:-crop_h, crop_w:-crop_w]
del obj
self.assertEqual(True, ret)
# create output data folder
mkdir_p(cfg.exp_path, cfg.params[cfg.opt_prnt])
if not cfg.cond_meta_file():
# automatic calibration data selection
obj = CaliFinder(cfg, sta)
ret = obj.main()
wht_img = obj.wht_bay[
crop_h:-crop_h,
crop_w:-crop_w] if obj.wht_bay is not None else obj.wht_bay
del obj
self.assertEqual(True, ret)
meta_cond = not (os.path.exists(cfg.params[cfg.cal_meta]) and
cfg.params[cfg.cal_meta].lower().endswith('json'))
if meta_cond or cfg.params[cfg.opt_cali]:
# perform centroid calibration
obj = LfpCalibrator(wht_img, cfg, sta)
ret = obj.main()
cfg = obj.cfg
del obj
self.assertEqual(True, ret)
# load calibration data
cfg.load_cal_data()
# write centroids as png file
if wht_img is not None:
obj = CentroidDrawer(wht_img, cfg.calibs[cfg.mic_list], cfg)
ret = obj.write_centroids_img(
fn=os.path.join(cfg.exp_path, 'wht_img+mics.png'))
del obj
self.assertEqual(True, ret)
# check if light field alignment has been done before
if cfg.cond_lfp_align():
# align light field
obj = LfpAligner(lfp_img, cfg, sta, wht_img)
ret = obj.main()
del obj
self.assertEqual(True, ret)
# load previously computed light field alignment
with open(os.path.join(cfg.exp_path, 'lfp_img_align.pkl'),
'rb') as f:
lfp_img_align = pickle.load(f)
# extract viewpoint data
CaliFinder(cfg).main()
obj = LfpExtractor(lfp_img_align, cfg=cfg, sta=sta)
ret = obj.main()
vp_img_arr = obj.vp_img_arr
del obj
self.assertEqual(True, ret)
# do refocusing
if cfg.params[cfg.opt_refo]:
obj = LfpRefocuser(vp_img_arr, cfg=cfg, sta=sta)
ret = obj.main()
del obj
self.assertEqual(True, ret)
return True