def test_lfp(self): # set config for unit test purposes cfg = PlenopticamConfig() cfg.params[cfg.opt_dbug] = True for fn_lfp, fn_wht in zip(self.fnames_lfp, self.fnames_wht): # update file paths and calibration data in config cfg.params[cfg.lfp_path] = os.path.join(self.fp, fn_lfp) cfg.params[cfg.cal_path] = os.path.join(self.fp, fn_wht) cfg.params[cfg.cal_meta] = os.path.splitext( cfg.params[cfg.cal_path])[0] + '.json' cfg.load_cal_data() # create folder (if it doesn't already exist) misc.mkdir_p(os.path.splitext(cfg.params[cfg.lfp_path])[0]) # test light field alignment lfp_img = misc.load_img_file(cfg.params[cfg.lfp_path]) lfp_obj = LfpAligner(lfp_img=lfp_img, cfg=cfg, sta=None) ret_val = lfp_obj.main() lfp_img = lfp_obj.lfp_img del lfp_obj # assertion self.assertEqual(True, ret_val) # test light field extraction lfp_obj = LfpExtractor(lfp_img_align=lfp_img, cfg=cfg, sta=None) ret_val = lfp_obj.main() del lfp_obj # assertion self.assertEqual(True, ret_val)
def test_cal(self): # set config for unit test purposes sta = PlenopticamStatus() cfg = PlenopticamConfig() cfg.reset_values() cfg.params[cfg.opt_dbug] = False cfg.params[cfg.opt_prnt] = True for fn_lfp, fn_wht in zip(self.fnames_lfp, self.fnames_wht): # update file paths and calibration data in config cfg.params[cfg.lfp_path] = os.path.join(self.fp, fn_lfp) cfg.params[cfg.cal_path] = os.path.join(self.fp, fn_wht) # create folder (if it doesn't already exist) mkdir_p(os.path.splitext(cfg.params[cfg.lfp_path])[0]) # test light field calibration wht_img = load_img_file(cfg.params[cfg.cal_path]) cal_obj = LfpCalibrator(wht_img=wht_img, cfg=cfg, sta=sta) ret_val = cal_obj.main() del cal_obj # assertion self.assertEqual(True, ret_val)
def test_custom_cal(self): for fn_lfp, fn_wht in zip(self.loader.opex_fnames_lfp, self.loader.opex_fnames_wht): # generate console output to prevent abort in Travis CI print(fn_wht) # update file paths and calibration data in config self.cfg.params[self.cfg.lfp_path] = join(self.fp, fn_lfp) self.cfg.params[self.cfg.cal_path] = join(self.fp, fn_wht) # create folder (if it doesn't already exist) mkdir_p(splitext(self.cfg.params[self.cfg.lfp_path])[0]) # test light field calibration wht_img = load_img_file(self.cfg.params[self.cfg.cal_path]) cal_obj = LfpCalibrator(wht_img=wht_img, cfg=self.cfg, sta=self.sta) ret_val = cal_obj.main() del cal_obj # assertion self.assertEqual(True, ret_val)
def crop_imgs(folder, coords_lists): img_tiles, files = list(), list() exts = ('tif', 'tiff', 'png') misc.mkdir_p(os.path.join(folder, 'auto-crop')) files = [ f for f in os.listdir(folder) if f.endswith(exts) and not f.startswith('.') ] files.sort() for i, file in enumerate(files): coords_nested = coords_lists[i] for j, coords in enumerate(coords_nested): if coords[0] != 0 and coords[1] != 0: cy, cx, h, w = coords img = misc.load_img_file(os.path.join(folder, file)) tile = img[cy - h // 2:cy + h // 2, cx - w // 2:cx + w // 2, ...] img_tiles.append(tile) fn, ext = os.path.splitext(file) misc.save_img_file(tile, os.path.join(folder, 'auto-crop', fn + '_crop' + str(j)), 'png', tag=True) return img_tiles, files
def get_list(img_dir, vp=1): from plenopticam import misc import numpy as np dir_list = os.listdir(img_dir) dir_list.sort() img_list = [] for i in dir_list: img_path = os.path.join(img_dir, i) ext = img_path.split('.')[::-1][0].lower() if ext in [gen_ext.replace('*.', '') for gen_ext in GENERIC_EXTS]: # load image img = misc.load_img_file(img_path) # convert to uint8 if necessary img = Normalizer( img=img).uint8_norm() if str(img.dtype) != 'uint8' else img # append to image list img_list.append((i, img)) # sort image list by indices in file names img_tuples = sorted(img_list, key=lambda k: idx_str_sort(k[0], 1 if vp else 0)) _, img_list = zip(*img_tuples) if vp: vp_dim = int(np.sqrt(len(img_list))) img_list = np.reshape(img_list, newshape=(vp_dim, vp_dim) + img_list[0].shape, order='C') return img_list
def test_cal(self): # set config for unit test purposes sta = PlenopticamStatus() cfg = PlenopticamConfig() cfg.reset_values() cfg.params[cfg.opt_dbug] = False cfg.params[ cfg. opt_prnt] = False # prevent Travis CI to terminate after reaching 4MB logfile size cfg.params[cfg.opt_vign] = False cfg.params[cfg.opt_sat_] = True for fn_lfp, fn_wht in zip(self.fnames_lfp, self.fnames_wht): # generate console output to prevent abort in Travis CI print(fn_wht) # update file paths and calibration data in config cfg.params[cfg.lfp_path] = os.path.join(self.fp, fn_lfp) cfg.params[cfg.cal_path] = os.path.join(self.fp, fn_wht) # create folder (if it doesn't already exist) mkdir_p(os.path.splitext(cfg.params[cfg.lfp_path])[0]) # test light field calibration wht_img = load_img_file(cfg.params[cfg.cal_path]) cal_obj = LfpCalibrator(wht_img=wht_img, cfg=cfg, sta=sta) ret_val = cal_obj.main() del cal_obj # assertion self.assertEqual(True, ret_val)
def test_pitch_estimator(self): from plenopticam.lfp_calibrator import PitchEstimator fns = [join(self.CEA_PATH, fn+'.png') for fn in ['a', 'b', 'c', 'd']] ref_sizes = [141, 50, 10, 6] for fn, ref_size in zip(fns, ref_sizes): img = load_img_file(fn) obj = PitchEstimator(img=img, cfg=self.cfg) obj.main() self.assertEqual(ref_size, obj.M)
def test_lfp(self): # set config for unit test purposes sta = PlenopticamStatus() cfg = PlenopticamConfig() cfg.reset_values() cfg.params[cfg.opt_dbug] = False cfg.params[ cfg. opt_prnt] = False # prevent Travis CI to terminate after reaching 4MB logfile size for fn_lfp, fn_wht in zip(self.fnames_lfp, self.fnames_wht): # generate console output to prevent abort in Travis CI print(fn_lfp) # update file paths and calibration data in config cfg.params[cfg.lfp_path] = os.path.join(self.fp, fn_lfp) cfg.params[cfg.cal_path] = os.path.join(self.fp, fn_wht) cfg.params[cfg.cal_meta] = os.path.splitext( cfg.params[cfg.cal_path])[0] + '.json' cfg.load_cal_data() # create folder (if it doesn't already exist) mkdir_p(os.path.splitext(cfg.params[cfg.lfp_path])[0]) # test light field alignment lfp_img = load_img_file(cfg.params[cfg.lfp_path]) lfp_obj = LfpAligner(lfp_img=lfp_img, cfg=cfg, sta=sta) ret_val = lfp_obj.main() lfp_img = lfp_obj.lfp_img del lfp_obj # assertion self.assertEqual(True, ret_val) # test light field extraction lfp_obj = LfpExtractor(lfp_img_align=lfp_img, cfg=cfg, sta=sta) lfp_obj.main() vp_img_arr = lfp_obj.vp_img_arr del lfp_obj lfp_obj = LfpRefocuser(vp_img_arr=vp_img_arr, cfg=cfg, sta=sta) lfp_obj.main() del lfp_obj # assertion self.assertEqual(True, ret_val)
def test_custom_lfp(self): for fn_lfp, fn_wht in zip(self.loader.opex_fnames_lfp, self.loader.opex_fnames_wht): # generate console output to prevent abort in Travis CI print(fn_lfp) # update file paths and calibration data in config self.cfg.params[self.cfg.lfp_path] = join(self.fp, fn_lfp) self.cfg.params[self.cfg.cal_path] = join(self.fp, fn_wht) self.cfg.params[self.cfg.cal_meta] = splitext( self.cfg.params[self.cfg.cal_path])[0] + '.json' self.cfg.load_cal_data() # create folder (if it doesn't already exist) mkdir_p(splitext(self.cfg.params[self.cfg.lfp_path])[0]) # test light field alignment lfp_img = load_img_file(self.cfg.params[self.cfg.lfp_path]) lfp_obj = LfpAligner(lfp_img=lfp_img, cfg=self.cfg, sta=self.sta) ret_val = lfp_obj.main() lfp_img = lfp_obj.lfp_img del lfp_obj # assertion self.assertEqual(True, ret_val) # test light field extraction lfp_obj = LfpExtractor(lfp_img_align=lfp_img, cfg=self.cfg, sta=self.sta) ret_val = lfp_obj.main() vp_img_arr = lfp_obj.vp_img_arr del lfp_obj # assertion self.assertEqual(True, ret_val) lfp_obj = LfpRefocuser(vp_img_arr=vp_img_arr, cfg=self.cfg, sta=self.sta) ret_val = lfp_obj.main() del lfp_obj # assertion self.assertEqual(True, ret_val)
def main(self): # check interrupt status if self.sta.interrupt: return False if self._lfp_path.lower().endswith(SUPP_FILE_EXT): try: self.decode_lytro_file() except FileNotFoundError: # print status self.sta.status_msg( '{0} not found'.format(os.path.basename(self._lfp_path)), self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) self.sta.error = True except Exception as e: # unrecognized LFP file type if not self._json_dict: raise LfpTypeError(e) else: raise PlenopticamError(e) else: try: # read and decode generic image file type self._lfp_img = misc.load_img_file(self._lfp_path) # inverse sRGB conversion self._lfp_img = GammaConverter().srgb_conv(self._lfp_img, inverse=True) except TypeError: self.sta.status_msg('File type not recognized') self.sta.error = True return False try: # try to load json file (if present) json_dict = self.cfg.load_json(self._lfp_path) self.cfg.lfpimg = LfpDecoder.filter_lfp_json( json_dict, self.cfg.lfp_img) except: pass # write json file self.cfg.save_params() return True
def test_real_data(self): self.depth_map, _ = load_pfm( '../examples/data/gradient_rose_close/depth.pfm') self.rgb_img = load_img_file( '../examples/data/gradient_rose_close/thumbnail.png') self.lfp_depth_obj = LfpDepth(depth_map=self.depth_map) # test invalid downscale parameters for i in range(-1, 5): print(i) try: self.lfp_depth_obj.plot_point_cloud(rgb_img=self.rgb_img, down_scale=i) except PlenopticamError as e: self.assertTrue(e, PlenopticamError) # test Axes3D argument import matplotlib.pyplot as plt fig, ax = plt.figure(), plt.axes(projection='3d') self.lfp_depth_obj.plot_point_cloud(down_scale=4, view_angles=(50, 70), ax=ax)
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
crop_opt = False score_series = list() for i, target_folder in enumerate(target_folders): fp = os.path.join(path, target_folder) files = [f for f in os.listdir(fp) if f.endswith(exts)] files.sort() scores = list() for file in files: # skip file if missing if os.path.splitext(file)[0].split('_')[0] not in skip_list: img_ref = load_img_file(os.path.join(fp, file)) if target_folder.startswith('thumb_collection'): img_src = load_img_file( os.path.join( fp, 'other_views', os.path.splitext(file)[0] + '_2_7' + '.png')) else: img_src = load_img_file( os.path.join( fp, 'other_views', file.split('__')[0] + '28__' + file.split('__')[1])) score = hist_dist(img_ref, img_src) scores.append(score) print(file + ': %s' % scores[-1])
def main(self): if self._lfp_path.endswith(('.lfp', '.lfr', '.raw') + tuple('.c.'+str(num) for num in (0, 1, 2, 3))): # filename and file path from previously decoded data dp = os.path.splitext(self._lfp_path)[0] fn = os.path.basename(dp)+'.tiff' fp = os.path.join(dp, fn) # load previously generated tiff if present if os.path.exists(fp): try: self._lfp_img = misc.load_img_file(fp) except TypeError as e: self.sta.status_msg(e, self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) raise LfpTypeError(e) except FileNotFoundError as e: # print status self.sta.status_msg('File {0} not found'.format(self._lfp_path), self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) raise PlenopticamError(e) else: try: # Lytro type decoding with open(self._lfp_path, mode='rb') as file: # print status self.sta.status_msg('Decode Lytro image file', self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(None, self.cfg.params[self.cfg.opt_prnt]) # LFC and raw type decoding obj = LfpDecoder(file, self.cfg, self.sta) if self._lfp_path.endswith(('.lfp', '.lfr') + tuple('.c.'+str(num) for num in (0, 1, 2, 3))): # LFC type decoding obj.decode_lfc() self.cfg.save_json(os.path.join(dp, os.path.basename(dp)+'.json'), json_dict=obj.json_dict) elif self._lfp_path.endswith('.raw'): # raw type decoding obj.decode_raw() self._lfp_img = obj.rgb_img del obj # save bayer image as file misc.save_img_file(misc.uint16_norm(self._lfp_img), fp, type='tiff') # print status self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) except FileNotFoundError as e: # print status self.sta.status_msg('File {0} not found'.format(self._lfp_path), self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) raise PlenopticamError(e) else: try: # read and decode generic image file type self._lfp_img = misc.load_img_file(self._lfp_path) except TypeError as e: raise LfpTypeError(e) try: # try to load json file (if present) json_dict = self.cfg.load_json(self._lfp_path) self.cfg.lfpimg = LfpDecoder.filter_json(json_dict) except: pass # write json file self.cfg.save_params() return True
def main(self): if self._lfp_path.lower().endswith(SUPP_FILE_EXT): # filename and file path from previously decoded data dp = os.path.splitext(self._lfp_path)[0] fn = os.path.basename(dp) + '.tiff' fp = os.path.join(dp, fn) # load previously generated tiff if present if os.path.exists(fp): try: self._lfp_img = misc.load_img_file(fp) except FileNotFoundError: # print status self.sta.status_msg( '{0} not found'.format(os.path.basename( self._lfp_path)), self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) self.sta.error = True except TypeError as e: self.sta.status_msg(e, self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) raise LfpTypeError(e) else: try: # Lytro type decoding with open(self._lfp_path, mode='rb') as file: # LFC and raw type decoding obj = LfpDecoder(file, self.cfg, self.sta) if self._lfp_path.lower().endswith(SUPP_FILE_EXT[1:]): # LFC type decoding obj.decode_lfc() self.cfg.save_json(os.path.join( dp, os.path.basename(dp) + '.json'), json_dict=obj.json_dict) elif self._lfp_path.lower().endswith(SUPP_FILE_EXT[0]): # raw type decoding obj.decode_raw() self._lfp_img = obj.rgb_img del obj # save bayer image as file self.sta.status_msg( msg='Save raw image', opt=self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(None, self.cfg.params[self.cfg.opt_prnt]) misc.save_img_file(misc.Normalizer( self._lfp_img).uint16_norm(), fp, file_type='tiff') self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) except FileNotFoundError: # print status self.sta.status_msg( '{0} not found'.format(os.path.basename( self._lfp_path)), self.cfg.params[self.cfg.opt_prnt]) self.sta.progress(100, self.cfg.params[self.cfg.opt_prnt]) self.sta.error = True except Exception as e: # unrecognized LFP file type if not obj.json_dict: raise LfpTypeError(e) else: raise PlenopticamError(e) else: try: # read and decode generic image file type self._lfp_img = misc.load_img_file(self._lfp_path) except TypeError as e: raise LfpTypeError(e) try: # try to load json file (if present) json_dict = self.cfg.load_json(self._lfp_path) self.cfg.lfpimg = LfpDecoder.filter_json(json_dict) except: pass # write json file self.cfg.save_params() return True
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(): # 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
crop_opt = False score_series = list() for i, target_folder in enumerate(target_folders): fp = os.path.join(path, target_folder) files = [f for f in os.listdir(fp) if f.endswith(exts)] files.sort() scores = list() for file in files: # skip file if missing if os.path.splitext(file)[0].split('_')[0] not in skip_list: img = load_img_file(os.path.join(fp, file)) # extract image tile if crop_opt: img = img[2:-2, 2:-2, ...] if file.endswith('Thumb.png') else img cy, cx = [x // 2 for x in img.shape[:2]] hh, hw = [x // 10 for x in img.shape[:2]] img_tile = img[cy - hh:cy + hh + 1, cx - hw:cx + hw + 1] else: img_tile = img score = brisque_metric(Normalizer(img_tile).uint8_norm()) scores.append(score) print(file + ': %s' % scores[-1])
import numpy as np from plenopticam.misc import load_img_file def psnr(img1=None, img2=None, quant_steps=2**8 - 1): img1 = np.asarray(img1, dtype=np.float64) / img1.max() img2 = np.asarray(img2, dtype=np.float64) / img2.max() mse = np.mean((img1 - img2)**2) if mse == 0: return 100 return 20 * np.log10(quant_steps / np.sqrt(mse)) if __name__ == "__main__": img_ref = load_img_file( '/Users/Admin/Unterlagen/PhD/07 publications/18_plenopticam/IEEEtran_1st-revision/img/vign/build-sigd0.png' ) img_div = load_img_file( '/Users/Admin/Unterlagen/PhD/07 publications/18_plenopticam/IEEEtran_1st-revision/img/vign/build-div-sigd15.png' ) img_fit = load_img_file( '/Users/Admin/Unterlagen/PhD/07 publications/18_plenopticam/IEEEtran_1st-revision/img/vign/build-fit-sigd15.png' ) print(psnr(img_ref, img_div)) print(psnr(img_ref, img_fit))
# Text rendering with LaTeX from matplotlib import rc rc('font', **{'family': 'sans-serif', 'sans-serif': ['Helvetica']}) rc('text', usetex=True) # for Palatino # rc('font',**{'family':'serif','serif':['Palatino']}) # plenopticam objects cfg = PlenopticamConfig() sta = PlenopticamStatus() # file settings fname = './c' cfg.params[cfg.cal_path] = fname + '.png' cfg.params[cfg.cal_meth] = constants.CALI_METH[2] #'peak' # wht_img = load_img_file(cfg.params[cfg.cal_path]) crop = True # load ground truth (remove outlying centers) spots_grnd_trth = np.loadtxt(fname + '.txt') spots_grnd_trth = spots_grnd_trth[spots_grnd_trth[:, 1] > 0] spots_grnd_trth = spots_grnd_trth[spots_grnd_trth[:, 0] > 0] spots_grnd_trth = spots_grnd_trth[spots_grnd_trth[:, 1] < wht_img.shape[1]] spots_grnd_trth = spots_grnd_trth[spots_grnd_trth[:, 0] < wht_img.shape[0]] # ensure white image is monochromatic if len(wht_img.shape) == 3: wht_img = rgb2gry(wht_img)[..., 0] if wht_img.shape[-1] == 3 else wht_img # estimate micro image diameter obj = PitchEstimator(wht_img, cfg, sta)
elif platform.system() == 'Darwin': fp_lytro = '/Volumes/SD CARD 1/IEEEtran/img/refo_lytro' fp_ours = '/Volumes/SD CARD 1/IEEEtran/img/refo_upscale_7px' else: fp_lytro = '' fp_ours = '' # loop over directories for fp in [fp_lytro, fp_ours]: slice_fns = [f for f in os.listdir(fp) if f.__contains__('crop')] s_list = list() # loop over filenames in directory for slice_fn in slice_fns: # load cropped slice img_tile = misc.load_img_file(os.path.join(fp, slice_fn)) # remove alpha channel if present img_tile = img_tile[..., :3] # rescale tile for fair comparison img_tile = misc.img_resize(img_tile, 2.28122448) if fp.__contains__('refo_lytro') else img_tile # store results s_list.append((slice_fn, blur_metric(img_tile), michelson_contrast(img_tile))) for s in s_list: print(s)