def __init__(self,pc_file_u,pc_file_v, covfile, covfile_sublayer=None, pc_size=-1, params={}, preset=None): """ Initialize PCAFlow object. Parameters ---------- pc_file_u, pc_file_v : string Files containing the principal components in horizontal and vertical direction, respectively. These files should be .npy files, in which each row is a flattened principal component (i.e., the total size of these principal component matrices is NUM_PC x (WIDTH*HEIGHT). cov_file : string File containing the covariance matrix of size NUM_PC x NUM_PC for PCA-Flow. covfile_sublayer : string, optional File containing the covariance matrix for the layers (usually biased towards the first PCs). If PCA-Layers is used and this file is not given, use cov_file. pc_size : tuple, optional Size of principal components. Only required if PCs are not of size 512x256 or 1024x436. params : dict, optional Parameters. See parameters.py for documentation of parameters. preset : string Preset with useful parameter values for different datasets. Can be one of 'pcaflow_sintel' 'pcalayers_sintel' 'pcaflow_kitti' 'pcalayers_kitti' """ np.random.seed(1) self.params = defaults.get_parameters(params,preset) cprint('[PCAFlow] Initializing.', self.params) NC = int(self.params['NC']) self.NC = NC pc_u = np.load(pc_file_u) pc_v = np.load(pc_file_v) cov_matrix = np.load(covfile).astype('float32') if covfile_sublayer is not None: cov_matrix_sublayer = np.load(covfile_sublayer).astype('float32') else: cov_matrix_sublayer = None pc_w = 0 pc_h = 0 if pc_size==-1: # Try to guess principal component dimensions if pc_u.shape[1] == 1024*436: cprint('[PCAFLOW] Using PC dimensionality 1024 x 436', self.params) pc_w = 1024 pc_h = 436 elif pc_v.shape[1] == 512*256: cprint('[PCAFLOW] Using PC dimensionality 512 x 256', self.params) pc_w = 512 pc_h = 256 else: print('[PCAFLOW] *** ERROR *** ') print('[PCAFLOW] Could not guess dimensionality of principal components.') print('[PCAFLOW] Please provide as parameter.') sys.exit(1) self.PC = [] # Smooth principal components. self.pc_u = self.filter_pcs(pc_u,(pc_w,pc_h)).astype('float32') self.pc_v = self.filter_pcs(pc_v,(pc_w,pc_h)).astype('float32') self.cov_matrix = cov_matrix self.pc_w = pc_w self.pc_h = pc_h self.reshape_features=True ############################### # Feature matcher ############################### if self.params['features'].lower() == 'libviso' and libviso_available: self.feature_matcher = FeatureMatcherLibviso(self.params) elif self.params['features'].lower() == 'orb': self.feature_matcher = FeatureMatcherORB(self.params) elif self.params['features'].lower() == 'fast': self.feature_matcher = FeatureMatcherFast(self.params) elif self.params['features'].lower() == 'akaze' or not libviso_available: self.feature_matcher = FeatureMatcherAKAZE(self.params) else: print('[PCAFLOW] *** ERROR ***') print('[PCAFLOW] Unknown feature type {}. Please use "libviso" or "fast".'.format(self.params['features'])) sys.exit(1) if self.params['n_models'] <= 1: ############################## # Solver for PCA-Flow ############################## self.solver = RobustQuadraticSolver(self.pc_u, self.pc_v, self.cov_matrix, pc_size=(pc_w,pc_h), params=self.params) else: ############################## # Solver for PCA-Layers ############################## self.solver = EMSolver(self.pc_u, self.pc_v, self.cov_matrix, pc_size = (pc_w,pc_h), params=self.params, cov_matrix_sublayer=cov_matrix_sublayer) self.images = deque(maxlen=2) cprint('[PCAFLOW] Finished initializing.',self.params)