for method, dir in zip(method_list, dir_list):
        seq_results = []
        for seq in seq_list:
            print('sequence: {}'.format(seq))
            results_dir = dir + '/results/scale/'
            config = load_obj('{}/config'.format(dir))
            config['test_seq'] = [seq]
            config['data_dir'] = path_to_dset_downsized+config['img_resolution'] + '_res/'
            dpc = config['dpc']
            mode = config['pose_output_type']
            if dpc:
                prefix = 'dpc'
            else:
                prefix=''
            test_dset_loaders, _, _ = data_and_model_loader(config, None, None, seq=seq)

            data = load_obj('{}/{}_plane_fit'.format(results_dir, config['test_seq'][0]))
            
            dist_to_plane = data['dist_to_plane']
            fwd_pose_vec1 = data['fwd_pose_vec1']
            fwd_pose_vec2 = data['fwd_pose_vec2']
            inv_pose_vec1 = data['inv_pose_vec1']
            inv_pose_vec2 = data['inv_pose_vec2']
            gt_pose_vec = data['gt_pose_vec']
            vo_pose_vec = data['vo_pose_vec']
            num_inliers = data['num_inliers']
            normals = data['normal']
            if config['dpc'] == False:
                prefix = ''
            if config['dpc'] == True:
    ## uncomment for KITTI to oxford
    # config['estimator'] = 'orbslam'

    config['load_stereo'] = False
    config['augment_motion'] = False
    config['augment_backwards'] = False
    config['test_seq'] = [seq]
    config['minibatch'] = 1
    config['load_pretrained'] = True
    dpc = config['dpc']
    mode = config['pose_output_type']
    if dpc:
        prefix = 'dpc'
    else:
        prefix = ''
    test_dset_loaders, models, device = data_and_model_loader(
        config, pretrained_depth_path, pretrained_pose_path, seq=seq)
    depth_model, pose_model = models[0], models[1]
    os.makedirs('scale_results/plane_imgs', exist_ok=True)
    os.makedirs('scale_results/plane_imgs/{}'.format(config['test_seq'][0]),
                exist_ok=True)

    def pf(img_list, depth, intrinsics, img_for_plotting):
        img, d, K = img_list, depth, intrinsics
        img = img[int(v_crop_min_num * img_list.shape[0] /
                      v_crop_min_den):int(v_crop_max_num * img_list.shape[0] /
                                          v_crop_max_den),
                  int(u_crop_min_num * img_list.shape[1] /
                      u_crop_min_den):int(u_crop_max_num * img_list.shape[1] /
                                          u_crop_max_den)]
        d = d[int(v_crop_min_num * img_list.shape[0] /
                  v_crop_min_den):int(v_crop_max_num * img_list.shape[0] /
    splits_dir = '{}/data/splits/{}'.format(path_to_ws, benchmark)
    config = load_obj('{}/config'.format(dir))
    pretrained_depth_path = glob.glob(
        '{}/**depth**best-loss-val_seq-**-test_seq-{}**.pth'.format(dir,
                                                                    ''))[0]
    pretrained_pose_path = glob.glob(
        '{}/**pose**best-loss-val_seq-**-test_seq-{}**.pth'.format(dir, ''))[0]

    config['data_dir'] = path_to_dset_downsized + config[
        'img_resolution'] + '_res/'  #
    config['minibatch'] = 6
    config['load_pretrained'] = True

    _, models, device = data_and_model_loader(config,
                                              pretrained_depth_path,
                                              pretrained_pose_path,
                                              seq=None)
    depth_model, pose_model = models[0], models[1]

    if plane_rescaling == True:
        ### Plane Model
        from models.plane_net import PlaneModel, scale_recovery
        from losses import Plane_Height_loss
        plane_loss = Plane_Height_loss(config)
        plane_model = PlaneModel(config).to(config['device'])
        pretrained_plane_path = glob.glob(
            '../{}/**plane**.pth'.format(pretrained_plane_dir))[0]
        plane_model.load_state_dict(torch.load(pretrained_plane_path))
        plane_model.train(False).eval()

    test_dset = KittiLoaderPytorch(