def correct_outliers(img, n=2, perc=.2, sta=None):
# status init
sta = sta if sta is not None else misc.PlenopticamStatus()
sta.status_msg('Hot pixel removal', True)
for i in range(n, img.shape[0] - n):
for j in range(n, img.shape[1] - n):
win = img[i - n:i + n + 1, j - n:j + n + 1]
# hot pixel detection
num_hi = len(win[win > img[i, j] * (1 - perc)])
# dead pixel detection
num_lo = len(win[win < img[i, j] * (1 + perc)])
if num_hi < win.size / 5 or num_lo < win.size / 5:
# replace outlier by average of all directly adjacent pixels
img[i, j] = (sum(sum(img[i - 1:i + 2, j - 1:j + 2])) -
img[i, j]) / 8.
# progress update
sta.progress((i * img.shape[1] + (j + 1)) / img.size * 100, True)
return img
def correct_luma_outliers(img, n=2, perc=.2, sta=None):
# status init
sta = sta if sta is not None else misc.PlenopticamStatus()
sta.status_msg('Hot pixel removal', True)
# luma channel conversion
luma = misc.yuv_conv(img.copy())[..., 0]
for i in range(n, luma.shape[0] - n):
for j in range(n, luma.shape[1] - n):
win = luma[i - n:i + n + 1, j - n:j + n + 1]
# hot pixel detection
num_hi = len(win[win > luma[i, j] * (1 - perc)])
# dead pixel detection
num_lo = len(win[win < luma[i, j] * (1 + perc)])
if num_hi < win.size / 5 or num_lo < win.size / 5:
# replace outlier by average of all directly adjacent pixels
img[i, j, :] = (sum(sum(img[i - 1:i + 2, j - 1:j + 2, :])) -
img[i, j, :]) / 8.
# progress update
sta.progress((i * luma.shape[1] + (j + 1)) / luma.size * 100, True)
return img
def pitch_eval(mean_pitch, patch_size, sta=None):
''' provide odd patch size that is safe to use '''
sta = sta if sta is not None else misc.PlenopticamStatus()
# ensure patch size and mean patch size are odd
patch_size += np.mod(patch_size, 2) - 1
mean_pitch += np.mod(mean_pitch, 2) - 1
patch_safe = 3
# comparison of patch size and mean size
msg_str = None
if patch_size < mean_pitch and patch_size > 3:
patch_safe = patch_size
elif patch_size > mean_pitch:
patch_safe = mean_pitch
msg_str = 'Patch size ({0} px) is larger than micro image size and reduced to {1} pixels.'
elif patch_size < 3 and mean_pitch > 3:
patch_safe = mean_pitch
msg_str = 'Patch size ({0} px) is too small and increased to {1} pixels.'
elif patch_size < 3 and mean_pitch < 3:
sta.interrupt = True
raise Exception(
'Micro image dimensions are too small for light field computation.'
)
if msg_str:
# status update
sta.status_msg(msg_str.format(patch_size, mean_pitch), True)
return patch_safe
def __init__(self, lfp_img, cfg=None, sta=None, wht_img=None):
# input variables
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
self._lfp_img = lfp_img
self._wht_img = wht_img
def load_json(fp=None, sta=None):
sta = sta if sta is not None else misc.PlenopticamStatus()
# filename and filepath handling
if fp is not None and os.path.splitext(fp)[-1] != '.json':
fn = os.path.splitext(os.path.basename(fp))[0] + '.json'
fp = os.path.join(os.path.splitext(fp)[0], fn)
# load calibration data from json file
try:
with open(fp, 'r') as f:
json_dict = json.load(f)
except json.decoder.JSONDecodeError:
os.remove(fp)
sta.status_msg(
'Calibration JSON File may be corrupted. Attempt to delete file %s'
% fp,
opt=True)
raise PlenopticamError(
'Calibration JSON File may be corrupted. Attempt to delete file %s'
% fp)
except IsADirectoryError:
sta.status_msg('Provided location %s is a directory' % fp,
opt=True)
raise PlenopticamError('Provided location %s is a directory' % fp)
except FileNotFoundError:
sta.status_msg('Provided file %s does not exist' % fp, opt=True)
raise PlenopticamError('Provided file %s does not exist' % fp)
return json_dict
def __init__(self, *args, **kwargs):
# input variables
self._lfp_img = kwargs['lfp_img'] if 'lfp_img' in kwargs else None
self._wht_img = kwargs['wht_img'] if 'wht_img' in kwargs else None
self.cfg = kwargs['cfg'] if 'cfg' in kwargs else PlenopticamConfig()
self.sta = kwargs['sta'] if 'sta' in kwargs else misc.PlenopticamStatus()
# convert to float
self._lfp_img = self._lfp_img.astype('float64') if self._lfp_img is not None else None
self._wht_img = self._wht_img.astype('float64') if self._wht_img is not None else None
if self.cfg.calibs:
# micro lens array variables
self._CENTROIDS = np.asarray(self.cfg.calibs[self.cfg.mic_list])
self._LENS_Y_MAX = int(max(self._CENTROIDS[:, 2])+1) # +1 to account for index 0
self._LENS_X_MAX = int(max(self._CENTROIDS[:, 3])+1) # +1 to account for index 0
# micro image size evaluation
self._M = self.pitch_max(self.cfg.calibs[self.cfg.mic_list])
self._M = self.pitch_eval(self._M, self.cfg.params[self.cfg.ptc_leng], self.sta)
self._C = self._M//2
try:
self._DIMS = self._lfp_img.shape if len(self._lfp_img.shape) == 3 else self._lfp_img.shape + (1,)
except (TypeError, AttributeError):
pass
except IndexError:
self.sta.status_msg('Incompatible image dimensions: Please either use KxLx3 or KxLx1 array dimensions')
self.sta.error = True
def __init__(self, cfg=None, sta=None, *args, **kwargs):
super(PropagatingThread, self).__init__(*args, **kwargs)
# init
self.cfg = cfg if cfg is not None else PlenopticamConfig()
self.sta = sta if sta is not None else misc.PlenopticamStatus()
self.exc = None
self.ret = None
def __init__(self, lfp_img_align, cfg=None, sta=None):
self._lfp_img_align = lfp_img_align
self.cfg = cfg if cfg is not None else PlenopticamConfig()
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variable
self._vp_img_arr = []
def __init__(self, lfp_img_align, cfg=None, sta=None):
self._lfp_img_align = lfp_img_align
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variables
self._vp_img_arr = []
self._refo_stack = []
def __init__(self, img=None, min=None, max=None, dtype=None, sta=None):
self._dtype = img.dtype.__str__() if dtype is None else dtype
self._img = np.asarray(img,
dtype='float64') if img is not None else None
self._min = self._img.min() if min is None else min
self._max = self._img.max() if max is None else max
self.sta = sta if sta is not None else misc.PlenopticamStatus()
def __init__(self, lfp_img_align=None, cfg=None, sta=None):
# input variables
self._lfp_img_align = lfp_img_align
self.cfg = cfg if cfg is not None else PlenopticamConfig()
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# variables for viewpoint arrays
self.vp_img_arr = [] # gamma corrected
self.vp_img_linear = [] # linear gamma (for further processing)
def __init__(self, lfp_raw, cfg, sta=None, method='cubic'):
# input variables
self.lfp_raw = lfp_raw
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variables
self._method = method
# output variable
self._lfp_out = np.zeros(lfp_raw.shape)
def __init__(self, cfg=None, sta=None, lfp_path=None):
# input and output variables
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variables
self._lfp_path = lfp_path.lower() if lfp_path is not None else cfg.params[cfg.lfp_path].lower()
# output variables
self._lfp_img = None
self._wht_img = None
def __init__(self, img_buf, shape, cfg, sta=None):
# input variables
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
self._shape = shape
self._img_buf = img_buf
self._bit_pac = cfg.lfpimg['bit'] if 'bit' in cfg.lfpimg.keys() else 10
# internal variables
self._bay_img = None
# output variables
self._rgb_img = None
def __init__(self, cfg=None, sta=None, lfp_path=None):
# input and output variables
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variables
self._lfp_path = lfp_path if lfp_path is not None else cfg.params[
cfg.lfp_path]
# output variables
self._bay_img = None
self._lfp_img = None
self._json_dict = None
# filename and file path from previously decoded data
self.dp = os.path.splitext(self._lfp_path)[0]
self.fn = os.path.basename(self.dp) + '.tiff'
self.fp = os.path.join(self.dp, self.fn)
def __init__(self, bay_img=None, wht_img=None, cfg=None, sta=None):
# input variables
self.cfg = cfg if cfg is not None else PlenopticamConfig()
self.sta = sta if sta is not None else misc.PlenopticamStatus()
self._bay_img = bay_img.astype('float32') if isinstance(
bay_img, np.ndarray) else None
self._wht_img = wht_img.astype('float32') if isinstance(
wht_img, np.ndarray) else None
self._bit_pac = self.cfg.lfpimg[
'bit'] if 'bit' in self.cfg.lfpimg else 10
self._gains = self.cfg.lfpimg['awb'] if 'awb' in self.cfg.lfpimg else [
1, 1, 1, 1
]
self._bay_pat = self.cfg.lfpimg[
'bay'] if 'bay' in self.cfg.lfpimg else None
# output variables
self._rgb_img = np.array([])
def __init__(self, lfp_img, cfg, sta=None, method='cubic'):
# input variables
self._lfp_img = lfp_img[..., np.newaxis] if len(
lfp_img.shape) == 2 else lfp_img # add 3rd axis for 2D image
self.cfg = cfg
self.sta = sta if sta is not None else misc.PlenopticamStatus()
# internal variables
self._METHOD = method
self._CENTROIDS = np.asarray(self.cfg.calibs[self.cfg.mic_list])
self._M = LfpCropper.pitch_max(self.cfg.calibs[self.cfg.mic_list])
self._C = int((self._M - 1) / 2)
self._LENS_Y_MAX = int(max(self._CENTROIDS[:, 2]))
self._LENS_X_MAX = int(max(self._CENTROIDS[:, 3]))
self._DIMS = self._lfp_img.shape if len(
self._lfp_img.shape) == 3 else None
# output variable
self._lfp_out = np.zeros(lfp_img.shape)
def __init__(self, *args, **kwargs):
# input variables
self._lfp_img = kwargs['lfp_img'] if 'lfp_img' in kwargs else None
self._wht_img = kwargs['wht_img'] if 'wht_img' in kwargs else None
self.cfg = kwargs['cfg'] if 'cfg' in kwargs else PlenopticamConfig()
self.sta = kwargs[
'sta'] if 'sta' in kwargs else misc.PlenopticamStatus()
# convert to float
self._lfp_img = self._lfp_img.astype(
'float64') if self._lfp_img is not None else None
self._wht_img = self._wht_img.astype(
'float64') if self._wht_img is not None else None
# micro lens array variables
self._CENTROIDS = np.asarray(self.cfg.calibs[self.cfg.mic_list])
self._LENS_Y_MAX = int(max(self._CENTROIDS[:, 2]) +
1) # +1 to account for index 0
self._LENS_X_MAX = int(max(self._CENTROIDS[:, 3]) +
1) # +1 to account for index 0
# micro image size evaluation
self._M = self.pitch_max(self.cfg.calibs[self.cfg.mic_list])
self._M = self.pitch_eval(self._M, self.cfg.params[self.cfg.ptc_leng],
self.sta)
self._C = self._M // 2
if self._lfp_img is not None:
# get light field dimensions
self._DIMS = self._lfp_img.shape
# add 3rd axis for 2D image
self._lfp_img = self._lfp_img[..., np.newaxis] if len(
self._lfp_img.shape) == 2 else self._lfp_img
def proc_vp_arr(fun, vp_img_arr, **kwargs):
''' process viewpoint images based on provided function handle and argument data '''
sta = kwargs['sta'] if 'sta' in kwargs else misc.PlenopticamStatus()
cfg = kwargs['cfg'] if 'cfg' in kwargs else Config()
msg = kwargs['msg'] if 'msg' in kwargs else 'Viewpoint process'
sta.status_msg(msg, cfg.params[cfg.opt_dbug])
args = [
kwargs[key] for key in kwargs.keys()
if key not in ('cfg', 'sta', 'msg')
]
for j in range(vp_img_arr.shape[0]):
for i in range(vp_img_arr.shape[1]):
vp_img_arr[j, i, :, :, :] = fun(vp_img_arr[j, i, :, :, :], *args)
# progress update
percentage = (i * vp_img_arr.shape[1] +
(j + 1)) / (vp_img_arr.shape[0] *
vp_img_arr.shape[1] * 100)
sta.progress(percentage, cfg.params[cfg.opt_dbug])
return vp_img_arr
def main():
# create config object
cfg = PlenopticamConfig()
cfg.default_values()
cfg.reset_values()
# parse options
cfg = parse_options(sys.argv[1:], cfg)
# instantiate status object
sta = misc.PlenopticamStatus()
sta.bind_to_interrupt(sys.exit) # set interrupt
# select light field image(s) considering provided folder or file
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)
]
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]:
# 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')
# 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 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)
sta.status_msg(msg=cfg.params[cfg.lfp_path],
opt=cfg.params[cfg.opt_prnt])
try:
# decode light field image
lfp_obj = lfp_reader.LfpReader(cfg, sta, cfg.params[cfg.lfp_path])
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_img
del obj
else:
# manual calibration data selection
sta.status_msg(
'\r Please select white image calibration source manually',
cfg.params[cfg.opt_prnt])
# 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)
# export light field data
lfp_calibrator.CaliFinder(cfg).main()
exp_obj = lfp_extractor.LfpExtractor(lfp_img_align, cfg)
exp_obj.main()
del exp_obj
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 main():
# parse options
cfg = parse_options(sys.argv[1:])
# instantiate status object
sta = misc.PlenopticamStatus()
sta.bind_to_interrupt(sys.exit) # set interrupt
# set calibration folder path
cfg.params[cfg.cal_path] = "/Users/Admin/Pictures/Lytro_Illum/CalibFolder"
# select light field image
cfg.params[cfg.lfp_path] = misc.select_file(cfg.params[cfg.lfp_path], 'Select plenoptic image')
# decode light field image
lfp_obj = lfp_reader.LfpReader(cfg, sta, cfg.params[cfg.lfp_path])
lfp_obj.main()
lfp_img = lfp_obj.lfp_img
del lfp_obj
# create output data folder
misc.mkdir_p(cfg.params[cfg.lfp_path].split('.')[0], cfg.params[cfg.opt_prnt])
# check if light field alignment has been done before
if not os.path.exists(os.path.join(cfg.params[cfg.lfp_path].split('.')[0], 'lfp_img_align.pkl')):
# manual calibration data selection
sta.status_msg('\r Please select white image calibration source manually', cfg.params[cfg.opt_prnt])
# open selection window (at directory where current lfp file is located)
cfg.params[cfg.cal_path] = misc.select_file(cfg.params[cfg.lfp_path])
if os.path.isdir(cfg.params[cfg.cal_path]) or cfg.params[cfg.cal_path].endswith('.tar'):
# automatic calibration data selection
obj = lfp_calibrator.CaliFinder(cfg, sta)
obj.main()
wht_img = obj.wht_img
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].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()
# 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
lfp_img_align = pickle.load(open(os.path.join(cfg.params[cfg.lfp_path].split('.')[0], 'lfp_img_align.pkl'), 'rb'))
# export light field data
exp_obj = lfp_extractor.LfpExtractor(lfp_img_align, cfg)
exp_obj.main()
del exp_obj
def __init__(self, *args, **kwargs):
# variables
self._lfp_img = kwargs['lfp_img'] if 'lfp_img' in kwargs else None
self._wht_img = kwargs['wht_img'] if 'wht_img' in kwargs else None
self._lfp_img_align = kwargs[
'lfp_img_align'] if 'lfp_img_align' in kwargs else None
self.cfg = kwargs['cfg'] if 'cfg' in kwargs else PlenopticamConfig()
self.sta = kwargs[
'sta'] if 'sta' in kwargs else misc.PlenopticamStatus()
self._M = 0
self._C = 0
self._flip = kwargs['flip'] if 'flip' in kwargs else False
# convert to float
self._lfp_img = self._lfp_img.astype(
'float64') if self._lfp_img is not None else None
self._wht_img = self._wht_img.astype(
'float64') if self._wht_img is not None else None
if self.cfg.calibs:
# micro lens array variables
self._CENTROIDS = np.asarray(self.cfg.calibs[self.cfg.mic_list])
self._LENS_Y_MAX = int(max(self._CENTROIDS[:, 2]) +
1) # +1 to account for index 0
self._LENS_X_MAX = int(max(self._CENTROIDS[:, 3]) +
1) # +1 to account for index 0
# get pitch from aligned light field
self._M = self.lfp_align_pitch() if hasattr(self,
'_lfp_img') else self._M
# get mean pitch from centroids
mean_pitch = self.centroid_avg_pitch(self._CENTROIDS) if hasattr(
self, '_CENTROIDS') else self._M
# evaluate mean pitch size and user pitch size
self._Mn = self.safe_pitch_eval(
mean_pitch=mean_pitch,
user_pitch=int(self.cfg.params[self.cfg.ptc_leng]))
# check if chosen micro image size too large
if 0 < self._M < self._Mn:
# remove existing pickle file
fp = os.path.join(self.cfg.exp_path, 'lfp_img_align.pkl')
os.remove(fp)
# status update
self.sta.status_msg(
'Angular resolution mismatch in previous alignment. Redo process'
)
self.sta.error = True
# check if micro image size in valid range
elif self._M >= self._Mn > 0:
self.cfg.params[self.cfg.ptc_leng] = self._Mn
# check if micro image size not set
elif self._M == 0:
self._M = self._Mn
self.cfg.params[self.cfg.ptc_leng] = self._Mn
self._C = self._M // 2
try:
self._DIMS = self._lfp_img.shape if len(
self._lfp_img.shape) == 3 else self._lfp_img.shape + (1, )
except (TypeError, AttributeError):
pass
except IndexError:
self.sta.status_msg(
'Incompatible image dimensions: Please either use KxLx3 or KxLx1 array dimensions'
)
self.sta.error = True
wht_img = whiteImg.squeeze().numpy()
image = Image.open(img_dir+'Default/img_channel000_position005_time000000000_z000.bmp')
whiteImg = TF.to_tensor(image)
whiteImg/=whiteImg.sum()
lfp_img = whiteImg.squeeze().numpy()
if not cfg.params[cfg.cal_path]:
# 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')
# instantiate status object
sta = misc.PlenopticamStatus()
sta.bind_to_interrupt(sys.exit) # set interrupt
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()
if cfg.cond_lfp_align():
# align light field
