sfm_code/create_point_clouds.py

import numpy as np
import cv2
import open3d as o3d
import os
import sys
from scipy.spatial.transform import Rotation as Rot
from scipy.sparse import lil_matrix
from scipy.optimize import least_squares
from sklearn.cluster import KMeans
import argparse
import time
import itertools

parser = argparse.ArgumentParser()
parser.add_argument('--num', help='Cur run', required=True)
args = parser.parse_args()
cur_process_id = int(args.num)


def get_keypoints_from_indices(keypoints1, index_list1, keypoints2, index_list2):
    """Filters a list of keypoints based on the indices given"""
    points1 = np.array([kp.pt for kp in keypoints1])[index_list1]
    points2 = np.array([kp.pt for kp in keypoints2])[index_list2]
    return points1, points2


def get_3D_point(u1, P1, u2, P2):
    """Solves for 3D point using homogeneous 2D points and the respective camera matrices"""
    A = np.array([[u1[0] * P1[2, 0] - P1[0, 0], u1[0] * P1[2, 1] - P1[0, 1], u1[0] * P1[2, 2] - P1[0, 2]],
                  [u1[1] * P1[2, 0] - P1[1, 0], u1[1] * P1[2, 1] - P1[1, 1], u1[1] * P1[2, 2] - P1[1, 2]],
                  [u2[0] * P2[2, 0] - P2[0, 0], u2[0] * P2[2, 1] - P2[0, 1], u2[0] * P2[2, 2] - P2[0, 2]],
                  [u2[1] * P2[2, 0] - P2[1, 0], u2[1] * P2[2, 1] - P2[1, 1], u2[1] * P2[2, 2] - P2[1, 2]]])
    B = np.array([-(u1[0] * P1[2, 3] - P1[0, 3]),
                  -(u1[1] * P1[2, 3] - P1[1, 3]),
                  -(u2[0] * P2[2, 3] - P2[0, 3]),
                  -(u2[1] * P2[2, 3] - P2[1, 3])])
    X = cv2.solve(A, B, flags=cv2.DECOMP_SVD)
    return X[1]


def remove_outliers_using_F(view1, view2, match_object):
    """Removes outlier keypoints using the fundamental matrix"""
    pixel_points1, pixel_points2 = get_keypoints_from_indices(keypoints1=view1.keypoints,
                                                              keypoints2=view2.keypoints,
                                                              index_list1=match_object.indices1,
                                                              index_list2=match_object.indices2)
    if len(pixel_points1) <= 8:  # A minimum of 8 points is required to calculate the fundamental matrix
        return None
    F, mask = cv2.findFundamentalMat(pixel_points1, pixel_points2, method=cv2.FM_RANSAC,
                                     ransacReprojThreshold=0.3, confidence=0.9999)
    mask = mask.astype(bool).flatten()
    match_object.inliers1 = np.array(match_object.indices1)[mask]
    match_object.inliers2 = np.array(match_object.indices2)[mask]
    return F


def calculate_reprojection_error(point_3D, point_2D, k, R, t):
    """Calculates the reprojection error for a 3D point by projecting it back into the image plane"""
    reprojected_point = k.dot(R.dot(point_3D) + t)
    if reprojected_point[-1][0] < 0:
        return 999
    reprojected_point = cv2.convertPointsFromHomogeneous(reprojected_point.T)[:, 0, :].T
    error = np.linalg.norm(point_2D.reshape((2, 1)) - reprojected_point)
    return error


def get_camera_from_E(E):
    """Calculates rotation and translation component from essential matrix"""
    W = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]])
    W_t = W.T
    u, w, vt = np.linalg.svd(E)
    R1 = u @ W @ vt
    R2 = u @ W_t @ vt
    t1 = u[:, -1].reshape((3, 1))
    t2 = - t1
    return R1, R2, t1, t2


def check_determinant(R):
    """Validates using the determinant of the rotation matrix"""
    if np.linalg.det(R) + 1.0 < 1e-9:
        return False
    else:
        return True


def check_triangulation(points, P):
    """Checks whether reconstructed points lie in front of the camera"""
    P = np.vstack((P, np.array([0, 0, 0, 1])))
    reprojected_points = cv2.perspectiveTransform(src=points[np.newaxis], m=P)
    z = reprojected_points[0, :, -1]
    if (np.sum(z > 0)/z.shape[0]) < 0.75:
        return False
    else:
        return True


class Match:
    """Represents a feature match between two views"""
    def __init__(self, view1, view2, use_spatial_consistency_check=0):
        self.indices1 = []  # indices of the matched keypoints in the first view
        self.indices2 = []  # indices of the matched keypoints in the second view
        self.distances = []  # distance between the matched keypoints in the first view
        self.image_name1 = view1.name  # name of the first view
        self.image_name2 = view2.name  # name of the second view
        self.root_path = view1.root_path  # root directory containing the image folder
        # list to store the indices of the keypoints from the first view not removed using the fundamental matrix
        self.inliers1 = []
        # list to store the indices of the keypoints from the second view not removed using the fundamental matrix
        self.inliers2 = []
        self.view1 = view1
        self.view2 = view2
        self.use_spatial_consistency_check = use_spatial_consistency_check  # value for spatial consistency check
        if view1.feature_type in ['sift', 'surf']:
            self.matcher = cv2.BFMatcher(cv2.NORM_L2)  # Added for Lowes ratio test
        else:
            self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
        self.get_matches(view1, view2)

    def get_matches(self, view1, view2):
        """ Extracts feature matches between two views """
        matches = self.matcher.knnMatch(view1.descriptors, view2.descriptors, k=2)  # k=2 for Lowes ratio test
        good_matches = []
        for m, n in matches:
            # Only accept matches where the best match is significantly better than the second best
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
        # sort the found matches according to their feature distance
        matches = sorted(good_matches, key=lambda x: x.distance)
        # store match components in their respective lists
        for i in range(len(matches)):
            self.indices1.append(matches[i].queryIdx)
            self.indices2.append(matches[i].trainIdx)
            self.distances.append(matches[i].distance)
        if self.use_spatial_consistency_check > 0:
            # Apply the Spatial Consistency Check
            # See https://ieeexplore.ieee.org/document/5459459
            nv1 = (np.sqrt(np.sum((np.array([view1.keypoints[ckp].pt for ckp in range(len(view1.keypoints))])[None, :]
                                  - np.array([view1.keypoints[ckp].pt for ckp in range(len(view1.keypoints))])[:,
                                  None]) ** 2, axis=-1)) < self.use_spatial_consistency_check) * \
                  (np.array([view1.keypoints[ckp].size for ckp in range(len(view1.keypoints))])[None, :]
                   / np.array([view1.keypoints[ckp].size for ckp in range(len(view1.keypoints))])[:, None] < 2) * \
                  (np.array([view1.keypoints[ckp].size for ckp in range(len(view1.keypoints))])[None, :]
                   / np.array([view1.keypoints[ckp].size for ckp in range(len(view1.keypoints))])[:, None] > 0.5)
            nv2 = (np.sqrt(np.sum((np.array([view2.keypoints[ckp].pt for ckp in range(len(view2.keypoints))])[None, :]
                                  - np.array([view2.keypoints[ckp].pt for ckp in range(len(view2.keypoints))])[:,
                                  None]) ** 2, axis=-1)) < self.use_spatial_consistency_check) * \
                  (np.array([view2.keypoints[ckp].size for ckp in range(len(view2.keypoints))])[None, :]
                   / np.array([view2.keypoints[ckp].size for ckp in range(len(view2.keypoints))])[:, None] < 2) * \
                  (np.array([view2.keypoints[ckp].size for ckp in range(len(view2.keypoints))])[None, :]
                   / np.array([view2.keypoints[ckp].size for ckp in range(len(view2.keypoints))])[:, None] > 0.5)
            for cc in range(len(matches)):
                nvi1 = np.sum(nv1[self.indices1[cc], self.indices1])
                if nvi1 == 0:
                    continue
                Nc = np.sum(nv1[self.indices1[cc], self.indices1] * nv2[self.indices2[cc], self.indices2])
                if Nc/nvi1 >= 0.55:
                    self.indices1.append(self.indices1[cc])
                    self.indices2.append(self.indices2[cc])
                    self.distances.append(self.distances[cc])
            self.indices1 = self.indices1[len(matches):]
            self.indices2 = self.indices2[len(matches):]
            self.distances = self.distances[len(matches):]


class View:
    """Represents an image used in the reconstruction"""
    def __init__(self, image_path, root_path, data_pos, feature_type='sift'):
        self.name = image_path[image_path.rfind('/') + 1:-4]  # image name without extension
        self.image = cv2.imread(root_path + image_path)  # numpy array of the image
        self.keypoints = []  # list of keypoints obtained from feature extraction
        self.descriptors = []  # list of descriptors obtained from feature extraction
        self.feature_type = feature_type  # feature extraction method
        self.root_path = root_path  # root directory containing the image folder
        R = np.array(Rot.from_quat(data_pos[3:]).as_matrix())  # rotation matrix for the view
        self.R = np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]]) @ R  # rotate the matrix according to the real world
        self.t = np.array(-self.R @ data_pos[:3])[:, None]  # translation vector for the view
        self.extract_features()
        self.Rs = []
        self.ts = []

    def extract_features(self):
        """Extracts features from the image"""
        if self.feature_type == 'sift':
            detector = cv2.xfeatures2d.SIFT_create()
        elif self.feature_type == 'surf':
            detector = cv2.xfeatures2d.SURF_create()
        elif self.feature_type == 'orb':
            detector = cv2.ORB_create(nfeatures=1500)
        else:
            sys.exit(0)
        self.keypoints, self.descriptors = detector.detectAndCompute(self.image, None)


class SFM:
    """Represents the main reconstruction loop.
       See https://github.com/harish-vnkt/structure-from-motion/blob/master/sfm.py"""
    def __init__(self, views, matches, K, save_path=None, allow_all_matches=True, compare_calculated_Rt_to_real_Rt=True,
                 deg_threshold=10, t_threshold=100, run_id=0):
        self.deg_threshold = deg_threshold
        self.t_threshold = t_threshold
        # if true, for every reconstructed R/T values compare them to the recorded values
        # if the difference is > than the above thresholds, don't allow any matches between the corresponding views
        self.compare_calculated_Rt_to_real_Rt = compare_calculated_Rt_to_real_Rt
        # limit the coordinates to be within the relevant area
        self.area_lim = np.array([[-0.1, 45.5], [-0.1, 31.35], [0., 8.]])
        self.allow_all_matches = allow_all_matches  # if false, only good points will be added
        self.views = views  # list of views
        self.matches = matches  # dictionary of matches
        self.names = []  # image names
        self.done = []  # list of views that have been reconstructed
        self.K = K  # intrinsic matrix
        self.points_3D = np.zeros((0, 3))  # reconstructed 3D points
        self.points_3D_colors = np.zeros((0, 3))  # reconstructed 3D points
        self.point_counter = 0  # keeps track of the reconstructed points
        self.point_map = {}  # a dictionary of the 2D points that contributed to a given 3D point
        self.rev_point_map = {}
        self.errors = []  # list of mean reprojection errors taken at the end of every new view being added
        for view in self.views:
            self.names.append(view.name)
        if save_path == None:  # if no path is specified create one to save the point cloud data in
            if not os.path.exists(self.views[0].root_path + '/run' + str(run_id)):
                os.makedirs(self.views[0].root_path + '/run' + str(run_id))
            if not os.path.exists(self.views[0].root_path + '/run' + str(run_id) + '/points'):
                os.makedirs(self.views[0].root_path + '/run' + str(run_id) + '/points')
            # store results in a root_path/points
            self.results_path = os.path.join(self.views[0].root_path + "/run" + str(run_id), 'points')
        else:
            if not os.path.exists(save_path):
                os.makedirs(save_path)
            if not os.path.exists(save_path + '/points'):
                os.makedirs(save_path + '/points')
            # store results in a root_path/points
            self.results_path = os.path.join(save_path, 'points')

    def get_index_of_view(self, view):
        """Extracts the position of a view in the list of views"""
        return self.names.index(view.name)

    def remove_mapped_points(self, match_object, image_idx):
        """Removes points that have already been reconstructed in the completed views"""
        inliers1 = []
        inliers2 = []
        for i in range(len(match_object.inliers1)):
            if (image_idx, match_object.inliers1[i]) not in self.point_map:
                inliers1.append(match_object.inliers1[i])
                inliers2.append(match_object.inliers2[i])
        match_object.inliers1 = inliers1
        match_object.inliers2 = inliers2

    def compute_pose(self, view1, view2=None, is_baseline=False):
        """Computes the pose of the new view"""
        # procedure for baseline pose estimation
        if is_baseline and view2:
            match_object = self.matches[(view1.name, view2.name)]
            _ = remove_outliers_using_F(view1, view2, match_object)
            rpe1, rpe2 = self.triangulate(view1, view2)
            if rpe1 is not None:
                self.errors.append(np.mean(rpe1))
                self.errors.append(np.mean(rpe2))
            self.done.append(view1)
            self.done.append(view2)
        # procedure for estimating the pose of all other views
        else:
            errors = []
            # reconstruct unreconstructed points from all of the previous views
            for i, old_view in enumerate(self.done):
                try:
                    match_object = self.matches[(old_view.name, view1.name)]
                except KeyError:
                    continue
                F = remove_outliers_using_F(old_view, view1, match_object)
                if F is None:
                    continue
                if self.compare_calculated_Rt_to_real_Rt:
                    E = self.K.T @ F @ self.K
                    R1, R2, t1, t2 = get_camera_from_E(E)  # decompose E
                    if not check_determinant(R1):
                        R1, R2, t1, t2 = get_camera_from_E(-E)
                    R1e = R1 @ old_view.R
                    R2e = R2 @ old_view.R
                    t1e = old_view.t + old_view.R @ t1
                    t2e = old_view.t + old_view.R @ t2
                    deg_error1 = np.rad2deg(np.arccos((np.trace(R1e.T @ view1.R) - 1) / 2))
                    deg_error2 = np.rad2deg(np.arccos((np.trace(R2e.T @ view1.R) - 1) / 2))
                    t_error1 = np.max(np.abs(view1.t - t1e))
                    t_error2 = np.max(np.abs(view1.t - t2e))
                    if np.min([deg_error1, deg_error2]) > self.deg_threshold or np.min([t_error1, t_error2]) >\
                            self.t_threshold:
                        match_object.inliers1 = []
                        match_object.inliers2 = []
                        continue
                _, rpe = self.triangulate(old_view, view1)
                if rpe is None:
                    continue
                errors += rpe
            self.done.append(view1)
            if len(errors) != 0:
                self.errors.append(np.mean(errors))

    def triangulate(self, view1, view2):
        """Triangulates 3D points from two views whose poses have been recovered.
           Also updates the point_map dictionary"""
        K_inv = np.linalg.inv(self.K)
        P1 = np.hstack((view1.R, view1.t))
        P2 = np.hstack((view2.R, view2.t))
        match_object = self.matches[(view1.name, view2.name)]
        pixel_points1, pixel_points2 = get_keypoints_from_indices(keypoints1=view1.keypoints,
                                                                  keypoints2=view2.keypoints,
                                                                  index_list1=match_object.inliers1,
                                                                  index_list2=match_object.inliers2)
        if len(pixel_points1) == 0:
            return None, None
        # Also keep track of one descriptor per 3D point - #
        descriptors1 = np.array(view1.descriptors)[match_object.inliers1]
        # - #
        pixel_points1 = np.append(pixel_points1, np.ones((len(pixel_points1), 1)), axis=1)
        pixel_points2 = np.append(pixel_points2, np.ones((len(pixel_points2), 1)), axis=1)
        reprojection_error1 = []
        reprojection_error2 = []
        for i in range(len(pixel_points1)):
            u1 = pixel_points1[i, :]
            u2 = pixel_points2[i, :]
            u1_normalized = K_inv.dot(u1)
            u2_normalized = K_inv.dot(u2)
            point_3D = get_3D_point(u1_normalized, P1, u2_normalized, P2)
            point_3D_color = view1.image[int(u1[1]), int(u1[0])][::-1]
            col3, col2, col1 = view1.image[int(u1[1]), int(u1[0])]
            col6, col5, col4 = view2.image[int(u2[1]), int(u2[0])]
            error1 = calculate_reprojection_error(point_3D, u1[0:2], self.K, view1.R, view1.t)
            error2 = calculate_reprojection_error(point_3D, u2[0:2], self.K, view2.R, view2.t)
            good_point = True
            # if the error is too large or the point is outside the area, consider it as a bad point
            if error1 > 10 or error2 > 10 or point_3D[0] < self.area_lim[0, 0] or point_3D[0] > self.area_lim[0, 1] or \
                    point_3D[1] < self.area_lim[1, 0] or point_3D[1] > self.area_lim[1, 1] or point_3D[2] < \
                    self.area_lim[2, 0] or point_3D[2] > self.area_lim[2, 1]:
                good_point = False
                if not self.allow_all_matches:
                    continue
            # if the point lies behind the view, consider it as a bad point
            if (P1 @ np.append(point_3D, 1.))[2] < 0:
                good_point = False
                if not self.allow_all_matches:
                    continue
            if (self.get_index_of_view(view1), match_object.inliers1[i]) in self.point_map.keys():
                if (self.get_index_of_view(view2), match_object.inliers2[i]) in self.point_map.keys():
                    continue  # if both points already have existing matches continue
                else:
                    # the point from view 1 is already matched
                    cur_remap_point1, p_status1, *_ = self.point_map[(self.get_index_of_view(view1),
                                                                      match_object.inliers1[i])]
                    if good_point == False or p_status1 == True:
                        # if the new point is bad, or the previous point for view 1 is good, simply
                        # match the 2d point from view 2 to the same previous match of view 1
                        pv, ps, *_ = self.point_map[(self.get_index_of_view(view1), match_object.inliers1[i])]
                        self.point_map[(self.get_index_of_view(view2), match_object.inliers2[i])] = [pv, ps, col4, col5,
                                                                                                     col6]
                    else:  # reassign all 2d points for the previous match of view 1 to the new good point
                        for ckey, cval in self.point_map.items():
                            if cval[0] == cur_remap_point1:
                                self.point_map[ckey][:2] = [self.point_counter, True]
                        self.point_map[(self.get_index_of_view(view2), match_object.inliers2[i])] = [self.point_counter,
                                                                                                     True, col4, col5,
                                                                                                     col6]
                        self.rev_point_map[self.point_counter] = [self.get_index_of_view(view1), True, descriptors1[i]]
                        self.point_counter += 1
                        reprojection_error1.append(error1)
                        reprojection_error2.append(error2)
                        self.points_3D = np.concatenate((self.points_3D, point_3D.T), axis=0)
                        self.points_3D_colors = np.concatenate((self.points_3D_colors, [point_3D_color]), axis=0)
                continue
            if (self.get_index_of_view(view2), match_object.inliers2[i]) in self.point_map.keys():
                continue  # if the point on view 2 is already mapped, continue
            reprojection_error1.append(error1)
            reprojection_error2.append(error2)
            # add the new 3d point to the list and update the point maps
            self.points_3D = np.concatenate((self.points_3D, point_3D.T), axis=0)
            self.points_3D_colors = np.concatenate((self.points_3D_colors, [point_3D_color]), axis=0)
            self.rev_point_map[self.point_counter] = [self.get_index_of_view(view1), good_point, descriptors1[i]]
            # updates point_map with the key (index of view, index of point in the view) and value point_counter
            # multiple keys can have the same value because a 3D point is reconstructed using 2 points
            self.point_map[(self.get_index_of_view(view1), match_object.inliers1[i])] = [self.point_counter, good_point,
                                                                                         col1, col2, col3]
            self.point_map[(self.get_index_of_view(view2), match_object.inliers2[i])] = [self.point_counter, good_point,
                                                                                         col4, col5, col6]
            self.point_counter += 1
        return reprojection_error1, reprojection_error2

    def plot_points(self, name_ad=""):
        """Saves the reconstructed 3D points to ply files using Open3D"""
        number = len(self.done)
        filename = os.path.join(self.results_path, str(number) + '_images' + name_ad + '.ply')
        pcd = o3d.geometry.PointCloud()
        # only save points within the area
        good_points = np.where(
            (self.points_3D[:, 0] >= self.area_lim[0, 0]) * (self.points_3D[:, 0] <= self.area_lim[0, 1]) * (
                        self.points_3D[:, 1] >= self.area_lim[1, 0]) * (self.points_3D[:, 1] <= self.area_lim[1, 1]) * (
                        self.points_3D[:, 2] >= self.area_lim[2, 0]) * (self.points_3D[:, 2] <= self.area_lim[2, 1]))[0]
        pcd.points = o3d.utility.Vector3dVector(self.points_3D[good_points])
        pcd.colors = o3d.utility.Vector3dVector(self.points_3D_colors[good_points].astype(np.float) / 255.0)
        o3d.io.write_point_cloud(filename, pcd)

    def remap_mapped_points(self):
        """ Remap all points so they are numbered from 0 to #points - 1. This only changes the point maps, if 3d points
            without a single match exist. Those 3d points are removed """
        all_points = []
        for key, val in self.point_map.items():
            all_points.append(val[0])
        all_points = np.unique(all_points)
        remap = {cpoint: i for i, cpoint in enumerate(all_points)}
        for key, val in self.point_map.items():
            self.point_map[key][:2] = [remap[val[0]], val[1]]
        point_mask = np.zeros(self.point_counter).astype(bool)
        if len(all_points) != 0:
            point_mask[all_points] = True
        self.points_3D = self.points_3D[point_mask]
        self.points_3D_colors = self.points_3D_colors[point_mask]
        self.point_counter = len(all_points)
        # Take colors as an average over all included points - #
        temp_cols = {pi: [] for pi in range(self.point_counter)}
        for pkey, pval in self.point_map.items():
            temp_cols[pval[0]].append(pval[2:])
        for pi in range(self.point_counter):
            self.points_3D_colors[pi] = np.mean(np.array(temp_cols[pi]), axis=0).astype(int)
        # - #
        # Added for rev_mapped_points - #
        new_rev_point_map = {}
        for key, val in remap.items():
            new_rev_point_map[val] = self.rev_point_map[key]
        for key, val in new_rev_point_map.items():
            if val[0] == -1:
                for key2, val2 in self.point_map.items():
                    if val2[0] == key:
                        new_rev_point_map[key][:2] = [key2[0], False]
                        break
        self.rev_point_map = new_rev_point_map
        # - #

    def remove_double_mapped_points(self):
        """ Removes all 2d points that are mapped to more than 1 3d point. """
        vals_rev = {x: {} for x in range(self.point_counter)}
        for key, val in self.point_map.items():
            try:
                vals_rev[val[0]][key[0]].append(key[1])
            except KeyError:
                vals_rev[val[0]][key[0]] = [key[1]]
        for key, val in vals_rev.items():
            for key2, val2 in val.items():
                if len(val2) > 1:
                    for cur_v in val2:
                        if self.rev_point_map[self.point_map[(key2, cur_v)][0]][0] == key2:
                            self.rev_point_map[self.point_map[(key2, cur_v)][0]][:2] = [-1, False]
                        del self.point_map[(key2, cur_v)]

    def remove_3d_points_with_one_match(self, min_k=2):
        """ Removes all 3d points that have less than the min_k of 2d points mapped to it."""
        vals_rev = {x: {} for x in range(self.point_counter)}
        for key, val in self.point_map.items():
            try:
                vals_rev[val[0]][key[0]].append(key[1])
            except KeyError:
                vals_rev[val[0]][key[0]] = [key[1]]
        for key, val in vals_rev.items():
            if len(val) < min_k:
                self.rev_point_map[key][:2] = [-2, False]
                for key2, val2 in val.items():
                    del self.point_map[(key2, val2[0])]

    def reconstruct(self):
        """ Starts the main reconstruction loop for a given set of views and matches """
        # compute baseline pose
        baseline_view1, baseline_view2 = self.views[0], self.views[1]
        self.compute_pose(view1=baseline_view1, view2=baseline_view2, is_baseline=True)
        for i in range(2, len(self.views)):
            if i % 200 == 0:
                print("Reconstructing %d/%d" % (i, len(self.views)))
            self.compute_pose(view1=self.views[i])


def create_views(data_path, base_img_path, limit=100000, every_xth_image=10, start_v=590, text_file="/13.txt",
                 name_skip=22, use_interpolated_path=None, bad_images_path=None):
    """ Loops through the images and creates an array of views """
    info_file = data_path + text_file
    with open(info_file, "r") as f:
        data_info = f.readlines()
    # obtain the image names and position information from the file
    old_image_names = np.array([x.split(" ")[0].split("/")[1][name_skip:] for x in data_info[:limit]])[start_v:]
    old_data_pos = np.array([x.split("\n")[0].split(" ")[1:] for x in data_info[:limit]]).astype(float)[start_v:]
    image_names = old_image_names[::every_xth_image]
    # if provided, replace the position information with the interpolated position information
    if use_interpolated_path != None:
        data_poses = np.load(use_interpolated_path)
        data_pos = data_poses[start_v:limit:every_xth_image]
    else:
        data_pos = old_data_pos[::every_xth_image]
    # if provided, remove all images marked as bad
    if bad_images_path != None:
        good_imgs = np.where(np.load(bad_images_path)[start_v:limit:every_xth_image] == 1)[0]
        image_names = image_names[good_imgs]
        data_pos = data_pos[good_imgs]
    views = []
    for ci, image_name in enumerate(image_names):
        views.append(View(image_name, base_img_path, data_pos[ci]))
    return views


def create_matches(views, use_spatial_consistency_check=0, use_overlap_criterion=0., K=None):
    """ Computes matches between every possible pair of views and stores them in a dictionary. If the overlap
        criterion is used, only match 2 views, if the specified percentage of points can be seen in both views. """
    if use_overlap_criterion > 0:  # if true, create a 3d grid over the area
        test_coords = np.meshgrid(np.arange(0, 42, 2), np.arange(0, 30, 2), np.arange(0, 2, 4.6))
        test_coords = np.array([test_coords[0].flatten(), test_coords[1].flatten(), test_coords[2].flatten()]).T
        test_coords = np.append(test_coords, np.ones(len(test_coords))[:, None], axis=1)
    matches = {}
    for i in range(0, len(views) - 1):
        if i % 200 == 0:
            print("Creating Matches for %d/%d" % (i, len(views)))
        if use_overlap_criterion > 0:
            e_mat = np.append(views[i].R, views[i].t, axis=1)
            xyz = np.array([K @ e_mat @ rR for rR in test_coords])
            xyz_mask1 = (xyz[:, -1] > 0)
            xyz = xyz / xyz[:, -1, None]
            xyz_mask1 *= (xyz[:, 0] > 0) * (xyz[:, 0] < 640) * (xyz[:, 1] > 0) * (xyz[:, 1] < 480)
        for j in range(i+1, len(views)):
            if use_overlap_criterion > 0:
                e_mat = np.append(views[j].R, views[j].t, axis=1)
                xyz = np.array([K @ e_mat @ rR for rR in test_coords])
                xyz_mask2 = (xyz[:, -1] > 0)
                xyz = xyz / xyz[:, -1, None]
                xyz_mask2 *= (xyz[:, 0] > 0) * (xyz[:, 0] < 640) * (xyz[:, 1] > 0) * (xyz[:, 1] < 480)
                if np.sum(xyz_mask1 * xyz_mask2) / np.minimum(np.sum(xyz_mask1), np.sum(xyz_mask2)) < use_overlap_criterion:
                    continue
            matches[(views[i].name, views[j].name)] = Match(views[i], views[j], use_spatial_consistency_check)
    return matches


def rotate(points, rot_vecs):
    """ Rotate points by given rotation vectors. Rodrigues' rotation formula is used. """
    theta = np.linalg.norm(rot_vecs, axis=1)[:, np.newaxis]
    with np.errstate(invalid='ignore'):
        v = rot_vecs / theta
        v = np.nan_to_num(v)
    dot = np.sum(points * v, axis=1)[:, np.newaxis]
    cos_theta = np.cos(theta)
    sin_theta = np.sin(theta)
    return cos_theta * points + sin_theta * np.cross(v, points) + dot * (1 - cos_theta) * v


def project(points, camera_params, intrinsic_k):
    """Convert 3-D points to 2-D by projecting onto images."""
    points_proj = rotate(points, camera_params[:, :3])
    points_proj += camera_params[:, 3:6]
    # Prevent least squares to fit a point behind the views by dislocating them
    additional_cost = np.minimum(1e9 * points_proj[:, 2], 0)  # points behind the view have negative values in z
    points_proj = points_proj[:, :2] / points_proj[:, 2, np.newaxis]
    f1 = intrinsic_k[0]
    f2 = intrinsic_k[1]
    k1 = intrinsic_k[2]
    k2 = intrinsic_k[3]
    # edit for k1, k2 as shift params
    f_s = np.vstack((f1, f2)).T
    k_s = np.vstack((k1, k2)).T
    points_proj = f_s * points_proj + k_s
    return points_proj + additional_cost[:, None]


def fun_no_K_all_E(params, n_cameras, n_points, camera_indices, point_indices, points_2d, intrinsic_k):
    """Compute residuals.

    `params` contains camera parameters and 3-D coordinates.
    """
    camera_params = params[:n_cameras * 6].reshape((n_cameras, 6))
    points_3d = params[n_cameras * 6:].reshape((n_points, 3))
    points_proj = project(points_3d[point_indices], camera_params[camera_indices], intrinsic_k)
    return (points_proj - points_2d).ravel()


def bundle_adjustment_sparsity_no_K_all_E(n_cameras, n_points, camera_indices, point_indices):
    """ Creates and returns a sparsity matrix for the bundle adjustment. """
    m = camera_indices.size * 2
    n = n_cameras * 6 + n_points * 3
    A = lil_matrix((m, n), dtype=int)
    i = np.arange(camera_indices.size)
    for s in range(6):
        A[2 * i, camera_indices * 6 + s] = 1
        A[2 * i + 1, camera_indices * 6 + s] = 1
    for s in range(3):
        A[2 * i, n_cameras * 6 + point_indices * 3 + s] = 1
        A[2 * i + 1, n_cameras * 6 + point_indices * 3 + s] = 1
    return A


def fun_no_E_no_K(params, camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d):
    """Compute residuals.

    `params` contains 3-D coordinates.
    """
    camera_params = camera_params.reshape((n_cameras, 6))
    points_3d = params.reshape((n_points, 3))
    points_proj = project(points_3d[point_indices], camera_params[camera_indices], intrinsic_k)
    return (points_proj - points_2d).ravel()


def bundle_adjustment_sparsity_no_E_no_K(n_points, camera_indices, point_indices):
    """ Creates and returns a sparsity matrix for the bundle adjustment. """
    m = camera_indices.size * 2
    n = n_points * 3
    A = lil_matrix((m, n), dtype=int)
    i = np.arange(camera_indices.size)
    for s in range(3):
        A[2 * i, point_indices * 3 + s] = 1
        A[2 * i + 1, point_indices * 3 + s] = 1
    return A


def run_ba_no_E_no_K(sfm1, points_3d, views, use_bounds=False, bounds_xyz=(-1., 43., -1., 32., -1., 8.),
                     pos_3d_adjustment_error_limit=20):
    """ Runs bundle adjustment for 3d points only. """
    points_2d = []
    camera_indices = []
    point_indices = []
    sorted_keys = sorted(sfm1.point_map.items(), key=lambda x: x[1][0])
    camera_params = []
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
    for view in views:
        cur_R = Rot.from_matrix(view.R).as_rotvec()
        cur_t = view.t
        camera_params.append(np.hstack((cur_R, cur_t.flatten())))
    points_2d = np.array(points_2d)
    camera_indices = np.array(camera_indices)
    point_indices = np.array(point_indices)
    n_cameras = len(camera_params)
    camera_params = np.array(camera_params).ravel()
    n_points = points_3d.shape[0]
    x0 = points_3d.ravel()
    intrinsic_k = np.array([K[0, 0], K[1, 1], K[0, 2], K[1, 2]])
    A = bundle_adjustment_sparsity_no_E_no_K(n_points, camera_indices, point_indices)
    if use_bounds:
        bounds = np.zeros((len(x0), 2))
        bounds[0::3, 0] = bounds_xyz[0]
        bounds[1::3, 0] = bounds_xyz[2]
        bounds[2::3, 0] = bounds_xyz[4]
        bounds[0::3, 1] = bounds_xyz[1]
        bounds[1::3, 1] = bounds_xyz[3]
        bounds[2::3, 1] = bounds_xyz[5]
        x0[x0 < bounds[:, 0]] = bounds[x0 < bounds[:, 0], 0]
        x0[x0 > bounds[:, 1]] = bounds[x0 > bounds[:, 1], 1]
        res = least_squares(fun_no_E_no_K, x0, bounds=bounds.T, jac_sparsity=A, verbose=1, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    else:
        res = least_squares(fun_no_E_no_K, x0, jac_sparsity=A, verbose=1, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    to_remove = np.unique((np.where(np.abs(res.fun) > pos_3d_adjustment_error_limit)[0] / 2.).astype(int))
    remove_dict = {p: np.where(point_indices == p)[0] for p in np.unique(point_indices[to_remove])}
    new_to_remove = []
    for key, val in remove_dict.items():
        max_error = np.argmax(np.sum(np.abs(res.fun[2*val[:, None] + np.array([[0, 1]])]), axis=1))
        new_to_remove.append(val[max_error])
    to_remove = np.array(new_to_remove)
    to_del = []
    for tr in to_remove:
        ci = camera_indices[tr]
        pi = point_indices[tr]
        for key, val in sfm1.point_map.items():
            if key[0] == ci and val[0] == pi:
                to_del.append(key)
    for td in to_del:
        del sfm1.point_map[td]
    return res.x.reshape((n_points, 3)), len(to_remove)


def run_ba_final_no_k(sfm1, points_3d, camera_params, views, intrinsic_k, use_bounds=False,
                      bounds_xyz=(-1., 43., -1., 32., -1., 8.), std_lim=10, bounds_trans=0., bounds_rots=0.,
                      start_x0=None):
    """ Runs bundle adjustment for 3d points and extrinsic camera params. """
    points_2d = []
    camera_indices = []
    point_indices = []
    sorted_keys = sorted(sfm1.point_map.items(), key=lambda x: x[1][0])
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
    points_2d = np.array(points_2d)
    camera_indices = np.array(camera_indices)
    point_indices = np.array(point_indices)
    n_cameras = len(camera_params)
    n_points = points_3d.shape[0]
    x0 = np.hstack((camera_params.ravel(), points_3d.ravel()))
    A = bundle_adjustment_sparsity_no_K_all_E(n_cameras, n_points, camera_indices, point_indices)
    if use_bounds:
        bounds = np.zeros((len(x0), 2))
        if bounds_trans != 0:
            bounds[:n_cameras * 6:6, 0] = start_x0[:n_cameras * 6:6] - bounds_trans * np.abs(start_x0[:n_cameras * 6:6])
            bounds[:n_cameras * 6:6, 1] = start_x0[:n_cameras * 6:6] + bounds_trans * np.abs(start_x0[:n_cameras * 6:6])
            bounds[1:n_cameras * 6:6, 0] = start_x0[1:n_cameras * 6:6] - bounds_trans * np.abs(start_x0[1:n_cameras * 6:6])
            bounds[1:n_cameras * 6:6, 1] = start_x0[1:n_cameras * 6:6] + bounds_trans * np.abs(start_x0[1:n_cameras * 6:6])
            bounds[2:n_cameras * 6:6, 0] = start_x0[2:n_cameras * 6:6] - bounds_trans * np.abs(start_x0[2:n_cameras * 6:6])
            bounds[2:n_cameras * 6:6, 1] = start_x0[2:n_cameras * 6:6] + bounds_trans * np.abs(start_x0[2:n_cameras * 6:6])
        else:
            bounds[:n_cameras * 6:6, 0] = -np.inf
            bounds[:n_cameras * 6:6, 1] = np.inf
            bounds[1:n_cameras * 6:6, 0] = -np.inf
            bounds[1:n_cameras * 6:6, 1] = np.inf
            bounds[2:n_cameras * 6:6, 0] = -np.inf
            bounds[2:n_cameras * 6:6, 1] = np.inf
        if bounds_rots != 0:
            bounds[3:n_cameras * 6:6, 0] = start_x0[3:n_cameras * 6:6] - bounds_rots * np.abs(start_x0[3:n_cameras * 6:6])
            bounds[3:n_cameras * 6:6, 1] = start_x0[3:n_cameras * 6:6] + bounds_rots * np.abs(start_x0[3:n_cameras * 6:6])
            bounds[4:n_cameras * 6:6, 0] = start_x0[4:n_cameras * 6:6] - bounds_rots * np.abs(start_x0[4:n_cameras * 6:6])
            bounds[4:n_cameras * 6:6, 1] = start_x0[4:n_cameras * 6:6] + bounds_rots * np.abs(start_x0[4:n_cameras * 6:6])
            bounds[5:n_cameras * 6:6, 0] = start_x0[5:n_cameras * 6:6] - bounds_rots * np.abs(start_x0[5:n_cameras * 6:6])
            bounds[5:n_cameras * 6:6, 1] = start_x0[5:n_cameras * 6:6] + bounds_rots * np.abs(start_x0[5:n_cameras * 6:6])
        else:
            bounds[3:n_cameras * 6:6, 0] = -np.inf
            bounds[3:n_cameras * 6:6, 1] = np.inf
            bounds[4:n_cameras * 6:6, 0] = -np.inf
            bounds[4:n_cameras * 6:6, 1] = np.inf
            bounds[5:n_cameras * 6:6, 0] = -np.inf
            bounds[5:n_cameras * 6:6, 1] = np.inf
        bounds[n_cameras * 6::3, 0] = bounds_xyz[0]
        bounds[n_cameras * 6 + 1::3, 0] = bounds_xyz[2]
        bounds[n_cameras * 6 + 2::3, 0] = bounds_xyz[4]
        bounds[n_cameras * 6::3, 1] = bounds_xyz[1]
        bounds[n_cameras * 6 + 1::3, 1] = bounds_xyz[3]
        bounds[n_cameras * 6 + 2::3, 1] = bounds_xyz[5]
        x0[x0 < bounds[:, 0]] = bounds[x0 < bounds[:, 0], 0]
        x0[x0 > bounds[:, 1]] = bounds[x0 > bounds[:, 1], 1]
        res = least_squares(fun_no_K_all_E, x0, bounds=bounds.T, jac_sparsity=A, verbose=1, x_scale='jac', ftol=1e-4, method='trf',
                            args=(n_cameras, n_points, camera_indices, point_indices, points_2d, intrinsic_k))
    else:
        res = least_squares(fun_no_K_all_E, x0, jac_sparsity=A, verbose=1, x_scale='jac', ftol=1e-4, method='trf',
                            args=(n_cameras, n_points, camera_indices, point_indices, points_2d, intrinsic_k))
    if np.quantile(np.abs(res.fun), 0.99) < 1:
        to_remove = np.unique((np.where(np.abs(res.fun) > 2)[0] / 2.).astype(int))
    else:
        to_remove = np.unique((np.where(np.abs(res.fun) > std_lim * np.std(res.fun))[0]/2.).astype(int))
    remove_dict = {p: to_remove[point_indices[to_remove] == p] for p in np.unique(point_indices[to_remove])}
    new_to_remove = []
    for key, val in remove_dict.items():
        max_error = np.argmax(np.sum(np.abs(res.fun[2*val[:, None] + np.array([[0, 1]])]), axis=1))
        new_to_remove.append(val[max_error])
    to_remove = np.array(new_to_remove)
    to_del = []
    for tr in to_remove:
        ci = camera_indices[tr]
        pi = point_indices[tr]
        for key, val in sfm1.point_map.items():
            if key[0] == ci and val[0] == pi:
                to_del.append(key)
    for td in to_del:
        del sfm1.point_map[td]
    return res.x[:n_cameras * 6].reshape((n_cameras, 6)), res.x[n_cameras * 6:].reshape((n_points, 3)), len(to_remove)


def gibbs_separate(sfm1, points_3d, views, use_bounds=True, bounds_xyz=np.array([-0.1, 45.5, -0.1, 31.35, 0., 8.]),
                   gibbs_separation_limit=10, gibbs_improvement_factor=2.):
    """ Uses the described "gibbs separate method" to remove bad matches. """
    points_2d = []
    camera_indices = []
    point_indices = []
    sorted_keys = sorted(sfm1.point_map.items(), key=lambda x: x[1][0])
    camera_params = []
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
    for view in views:
        cur_R = Rot.from_matrix(view.R).as_rotvec()
        cur_t = view.t
        camera_params.append(np.hstack((cur_R, cur_t.flatten())))
    points_2d = np.array(points_2d)
    camera_indices = np.array(camera_indices)
    point_indices = np.array(point_indices)
    n_cameras = len(camera_params)
    camera_params = np.array(camera_params).ravel()
    n_points = points_3d.shape[0]
    x0 = points_3d.ravel()
    intrinsic_k = np.array([K[0, 0], K[1, 1], K[0, 2], K[1, 2]])
    A = bundle_adjustment_sparsity_no_E_no_K(n_points, camera_indices, point_indices)
    if use_bounds:
        bounds = np.zeros((len(x0), 2))
        bounds[0::3, 0] = bounds_xyz[0]
        bounds[1::3, 0] = bounds_xyz[2]
        bounds[2::3, 0] = bounds_xyz[4]
        bounds[0::3, 1] = bounds_xyz[1]
        bounds[1::3, 1] = bounds_xyz[3]
        bounds[2::3, 1] = bounds_xyz[5]
        x0[x0 < bounds[:, 0]] = bounds[x0 < bounds[:, 0], 0]
        x0[x0 > bounds[:, 1]] = bounds[x0 > bounds[:, 1], 1]
        res = least_squares(fun_no_E_no_K, x0, bounds=bounds.T, jac_sparsity=A, verbose=0, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    else:
        res = least_squares(fun_no_E_no_K, x0, jac_sparsity=A, verbose=0, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    to_remove = np.unique((np.where(np.abs(res.fun) > gibbs_separation_limit)[0] / 2.).astype(int))
    cor_3d_points = point_indices[to_remove]
    un_cor = np.unique(cor_3d_points)
    bounds1 = np.zeros((3, 2))
    bounds1[0, 0] = bounds_xyz[0]
    bounds1[1, 0] = bounds_xyz[2]
    bounds1[2, 0] = bounds_xyz[4]
    bounds1[0, 1] = bounds_xyz[1]
    bounds1[1, 1] = bounds_xyz[3]
    bounds1[2, 1] = bounds_xyz[5]
    to_remove = []
    for cucc, ucc in enumerate(un_cor):
        if cucc % 500 == 0:
            print("%d/%d" % (cucc, len(un_cor)))
        x1 = points_3d[ucc]
        points_2d1 = points_2d[np.where(point_indices == ucc)[0]]
        n_points1 = 1
        camera_indices1 = camera_indices[np.where(point_indices == ucc)[0]]
        point_indices1 = np.zeros(len(camera_indices1) - 1).astype(int)
        rev_pi = (np.where(point_indices == ucc)[0]*2).astype(int)
        start_errors = res.fun[np.insert(rev_pi + 1,  np.arange(len(rev_pi)), rev_pi)]
        p_mask = np.ones(len(points_2d1)).astype(bool)
        error_mask = np.ones(len(start_errors)).astype(bool)
        error_improvements = []
        for pi in range(len(p_mask)):
            p_mask[pi - 1] = True
            p_mask[pi] = False
            error_mask[(pi-1) * 2] = True
            error_mask[(pi-1) * 2 + 1] = True
            error_mask[pi * 2] = False
            error_mask[pi * 2 + 1] = False
            rev_errors = start_errors[error_mask]
            A1 = bundle_adjustment_sparsity_no_E_no_K(n_points1, camera_indices1[p_mask], point_indices1)
            res1 = least_squares(fun_no_E_no_K, x1, bounds=bounds1.T, jac_sparsity=A1, verbose=0, x_scale='jac', ftol=1e-4,
                                 method='trf',
                                 args=(
                                    camera_params, intrinsic_k, n_cameras, n_points1, camera_indices1[p_mask], point_indices1,
                                    points_2d1[p_mask]))
            error_improvements.append(np.sum(np.abs(rev_errors - res1.fun)))
        best_improve_ind = np.argmax(error_improvements)
        if error_improvements[best_improve_ind] > gibbs_improvement_factor * np.sort(error_improvements)[-2]:
            to_remove.append(np.where(point_indices == ucc)[0][best_improve_ind])
    to_remove = np.array(to_remove)
    print("Removing: %d" % len(to_remove))
    to_del = []
    for tr in to_remove:
        ci = camera_indices[tr]
        pi = point_indices[tr]
        for key, val in sfm1.point_map.items():
            if key[0] == ci and val[0] == pi:
                to_del.append(key)
    for td in to_del:
        del sfm1.point_map[td]


def cluster_remove(rep_errors, remove_dict):
    """ Separates corresponding matches for 3d points into 2 groups each. """
    to_remove = []
    for key, val in remove_dict.items():
        cor_2d = np.array([rep_errors[2 * x:2 * x + 2] for x in val])
        kmeans = KMeans(n_clusters=2, random_state=0).fit(cor_2d)
        l_to_remove = (len(cor_2d)/2 - np.sum(kmeans.labels_ == 0) < 0) + 0.
        to_remove.extend(val[kmeans.labels_ == l_to_remove])
    return np.array(to_remove)


def cluster_separate(sfm1, points_3d, views, use_bounds=True, bounds_xyz=np.array([-0.1, 45.5, -0.1, 31.35, 0., 8.]),
                     cluster_separation_limit=30):
    """ Uses the described "cluster separate method" to remove bad matches. """
    points_2d = []
    camera_indices = []
    point_indices = []
    sorted_keys = sorted(sfm1.point_map.items(), key=lambda x: x[1][0])
    camera_params = []
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
    for view in views:
        cur_R = Rot.from_matrix(view.R).as_rotvec()
        cur_t = view.t
        camera_params.append(np.hstack((cur_R, cur_t.flatten())))
    points_2d = np.array(points_2d)
    camera_indices = np.array(camera_indices)
    point_indices = np.array(point_indices)
    n_cameras = len(camera_params)
    camera_params = np.array(camera_params).ravel()
    n_points = points_3d.shape[0]
    x0 = points_3d.ravel()
    intrinsic_k = np.array([K[0, 0], K[1, 1], K[0, 2], K[1, 2]])
    A = bundle_adjustment_sparsity_no_E_no_K(n_points, camera_indices, point_indices)
    if use_bounds:
        bounds = np.zeros((len(x0), 2))
        bounds[0::3, 0] = bounds_xyz[0]
        bounds[1::3, 0] = bounds_xyz[2]
        bounds[2::3, 0] = bounds_xyz[4]
        bounds[0::3, 1] = bounds_xyz[1]
        bounds[1::3, 1] = bounds_xyz[3]
        bounds[2::3, 1] = bounds_xyz[5]
        x0[x0 < bounds[:, 0]] = bounds[x0 < bounds[:, 0], 0]
        x0[x0 > bounds[:, 1]] = bounds[x0 > bounds[:, 1], 1]
        res = least_squares(fun_no_E_no_K, x0, bounds=bounds.T, jac_sparsity=A, verbose=0, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    else:
        res = least_squares(fun_no_E_no_K, x0, jac_sparsity=A, verbose=0, x_scale='jac', ftol=1e-4,
                            method='trf',
                            args=(
                            camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d))
    # New remove method - #
    to_remove = np.unique((np.where(np.abs(res.fun) > cluster_separation_limit)[0] / 2.).astype(int))
    remove_dict = {p: np.where(point_indices == p)[0] for p in np.unique(point_indices[to_remove])}
    cluster_2d_points = cluster_remove(res.fun, remove_dict)
    if len(cluster_2d_points) == 0:
        return points_3d, 0
    cluster_3d_points = point_indices[cluster_2d_points]
    cur_num_points = sfm1.point_counter
    for cb, b3d in enumerate(np.unique(cluster_3d_points)):
        to_remap = cluster_2d_points[np.where(cluster_3d_points == b3d)[0]]
        cur_view = sorted_keys[to_remap[0]][0]
        cur_desc = views[cur_view[0]].descriptors[cur_view[1]]
        cur_col = views[cur_view[0]].image[int(views[cur_view[0]].keypoints[cur_view[1]].pt[1]),
                                           int(views[cur_view[0]].keypoints[cur_view[1]].pt[0])][::-1]
        sfm1.rev_point_map[cur_num_points + cb] = [cur_view[0], True, np.copy(cur_desc)]
        for tr in to_remap:
            sfm1.point_map[sorted_keys[tr][0]][0] = cur_num_points + cb
        sfm1.points_3D = np.vstack([sfm1.points_3D, np.zeros((1, 3))])
        sfm1.points_3D_colors = np.vstack([sfm1.points_3D_colors, np.copy(cur_col).reshape((1, 3))])
    sfm1.point_counter += len(np.unique(cluster_3d_points))
    for val in range(cur_num_points, cur_num_points + len(np.unique(cluster_3d_points))):
        cE = np.hstack((views[sfm1.rev_point_map[val][0]].R, views[sfm1.rev_point_map[val][0]].t))
        relevant_bounds = np.array([0, 2, 4]) + (cE[2, :3] > 0).astype(int)
        relevant_bounds = bounds_xyz[relevant_bounds]
        relevant_bounds[cE[2, :3] > 0] -= 1
        relevant_bounds[cE[2, :3] <= 0] += bounds_xyz[-2]
        cur_fac = np.min(((relevant_bounds - (np.linalg.inv(-cE[:, :3]) @ cE[:, 3])) / cE[2, :3])[:2])
        sfm1.points_3D[val] = (np.linalg.inv(-cE[:, :3]) @ cE[:, 3]) + cur_fac * cE[2, :3]
        if sfm1.points_3D[val][2] < 0:
            sfm1.points_3D[val][2] = 0.
    points_3d = np.vstack([points_3d, sfm1.points_3D[-len(np.unique(cluster_3d_points)):]])
    return points_3d, len(cluster_2d_points)


def separate_behind_points(sfm1, points_3d, views, bounds_xyz=np.array([-0.1, 45.5, -0.1, 31.35, 0., 8.])):
    """ Sets any points, that are behind a view, in front of it. """
    points_2d = []
    camera_indices = []
    point_indices = []
    sorted_keys = sorted(sfm1.point_map.items(), key=lambda x: x[1][0])
    camera_params = []
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
    for view in views:
        cur_R = Rot.from_matrix(view.R).as_rotvec()
        cur_t = view.t
        camera_params.append(np.hstack((cur_R, cur_t.flatten())))
    points_2d = np.array(points_2d)
    camera_indices = np.array(camera_indices)
    point_indices = np.array(point_indices)
    n_cameras = len(camera_params)
    camera_params = np.array(camera_params).ravel()
    n_points = points_3d.shape[0]
    x0 = points_3d.ravel()
    intrinsic_k = np.array([K[0, 0], K[1, 1], K[0, 2], K[1, 2]])
    f0 = fun_no_E_no_K(x0, camera_params, intrinsic_k, n_cameras, n_points, camera_indices, point_indices, points_2d)
    behind_2d_points = (np.where(np.abs(f0) > 1e6)[0]/2.).astype(int)
    if len(behind_2d_points) == 0:
        return points_3d, 0
    behind_3d_points = point_indices[behind_2d_points]
    cur_num_points = sfm1.point_counter
    for cb, b3d in enumerate(np.unique(behind_3d_points)):
        to_remap = behind_2d_points[np.where(behind_3d_points == b3d)[0]]
        cur_view = sorted_keys[to_remap[0]][0]
        cur_desc = views[cur_view[0]].descriptors[cur_view[1]]
        cur_col = views[cur_view[0]].image[int(views[cur_view[0]].keypoints[cur_view[1]].pt[1]),
                                           int(views[cur_view[0]].keypoints[cur_view[1]].pt[0])][::-1]
        sfm1.rev_point_map[cur_num_points + cb] = [cur_view[0], True, np.copy(cur_desc)]
        for tr in to_remap:
            sfm1.point_map[sorted_keys[tr][0]][0] = cur_num_points + cb
        sfm1.points_3D = np.vstack([sfm1.points_3D, np.zeros((1, 3))])
        sfm1.points_3D_colors = np.vstack([sfm1.points_3D_colors, np.copy(cur_col).reshape((1, 3))])
    sfm1.point_counter += len(np.unique(behind_3d_points))
    for val in range(cur_num_points, cur_num_points + len(np.unique(behind_3d_points))):
        cE = np.hstack((views[sfm1.rev_point_map[val][0]].R, views[sfm1.rev_point_map[val][0]].t))
        relevant_bounds = np.array([0, 2, 4]) + (cE[2, :3] > 0).astype(int)
        relevant_bounds = bounds_xyz[relevant_bounds]
        relevant_bounds[cE[2, :3] > 0] -= 1
        relevant_bounds[cE[2, :3] <= 0] += bounds_xyz[-2]
        cur_fac = np.min(((relevant_bounds - (np.linalg.inv(-cE[:, :3]) @ cE[:, 3])) / cE[2, :3])[:2])
        sfm1.points_3D[val] = (np.linalg.inv(-cE[:, :3]) @ cE[:, 3]) + cur_fac * cE[2, :3]
        if sfm1.points_3D[val][2] < 0:
            sfm1.points_3D[val][2] = 0.
    points_3d = np.vstack([points_3d, sfm1.points_3D[-len(np.unique(behind_3d_points)):]])
    return points_3d, len(behind_2d_points)


# !! The following numbers and paths need to be adjusted to your setup !! --------------------------------- #
name_skip = 3  # length of the string (in the text file) before the actual image name
text_file = "/11_12.txt"  # text file with the frame names/ translation values / quaternions
data_path = "..."  # path with all relevant files
use_interpolated_path = data_path + "/11_12_interp_0.0010_1.0000_4deg_cor.npy"  # None for not using interpolated gt
bad_images_path = data_path + "/frames_to_use_up_to_41500_visual_check_every_50th_image.npy"  # None for not excluding any frames
run_id = 8  # use any id (if it already exists the content will be replaced)
save_path_base = ".../sfm_results/run" + str(run_id) + "/p%d"  # path to save the created files
base_img_path = data_path + "/11_12_uwb_040321_abs4_images_50/"  # base path for the corresponding images
# --------------------------------------------------------------------------------------------------------- #


time_save_file_path_base = save_path_base + "/time_info_"  # file to save timing information
params_save_file_path_base = save_path_base + "/params_info.txt"  # file to write the parameters in
# lists the names of the parameters
param_names = ["start_view", "end_view", "step_size", "std_lim", "min_matches_per_point",
               "reset_points_for_final_adjustment", "spatial_consistency_check", "overlap_criterion",
               "separation_limits", "gibbs_improvement_factor"]
start_views = [0]  # 590
end_views = [41550] # 6840
step_sizes = [50]  # 5
std_lim_globs = [(3, 4), (4, 4), (5, 4)]  # (4, 4)
K = np.array([[548.44934818, 0., 317.73762648],
              [0., 549.17600512, 249.00614224],
              [0., 0., 1.]])
use_camera_pos_shift = False  # False # Should have a rather minor effect
# if True, place all 3d points in the middle of their corresponding first view (projected onto the next wall)
reset_all_points = True
save_all_descriptors = True  # if True, save the descriptors of all corresponding 2d points for every 3d point
min_matches_per_point_singles = [3, 4, 5]  # minimal number of matches necessary to keep a 3d point
# if True, the below bounds will be used for sfm/bundle adjustment. Only 3d points within the bounds
# will be saved in the point cloud
use_bounds = True
bounds_xyz = np.array([-0.1, 45.5, -0.1, 31.35, 0., 8.])
bounds_trans = 0.01  # allowed deviation from the original recorded positions # Set to 0 to not use them
bounds_rots = 0.01  # allowed deviation from the original recorded rotations # Set to 0 to not use them
# if True, reset 3d point values before the final adjustment (same reset method as reset_all_points)
reset_points_for_final_adjustments = [True, False]
use_spatial_consistency_checks = [0, 5, 7]  # value for spatial consistency check. if 0 no check is used
use_overlap_criterions = [0.2, 0.3, 0.4]  # value for overlap criterion. if 0 no no overlap criterion is used
# values for the different separation methods
separation_limits = [(40, 30, 30), (40, 30, 20), (40, 30, 10),
                     (40, 20, 30), (40, 20, 20), (40, 20, 10), (40, 10, 30), (40, 10, 20), (40, 10, 10),
                     (30, 30, 30), (30, 30, 20), (30, 30, 10),
                     (30, 20, 30), (30, 20, 20), (30, 20, 10), (30, 10, 30), (30, 10, 20), (30, 10, 10),
                     (20, 20, 20), (20, 20, 10), (20, 10, 20), (20, 10, 10)]
gibbs_improvement_factors = [2.]  # factor
all_params = list(itertools.product(start_views, end_views, step_sizes, std_lim_globs, min_matches_per_point_singles,
                                    reset_points_for_final_adjustments, use_spatial_consistency_checks,
                                    use_overlap_criterions, separation_limits, gibbs_improvement_factors))


def run_process(j, views=None):
    save_path = save_path_base % j
    if not os.path.exists(save_path):
        os.makedirs(save_path)
        print("-------------------- Dealing with: %d --------------------" % j)
    else:
        print("-------------------- Skipped: %d Already exists --------------------" % j)
        return
    time_save_file_path = (time_save_file_path_base % j) + str(int(time.time() * 1000)) + ".txt"
    params_save_file_path = params_save_file_path_base % j
    # Read current params -- #
    start_view = all_params[j][0]
    end_view = all_params[j][1]
    step_size = all_params[j][2]
    std_lim = np.copy(all_params[j][3][0])
    reduce_std_lim_to = all_params[j][3][1]
    min_matches_per_point_single = all_params[j][4]
    reset_points_for_final_adjustment = all_params[j][5]
    use_spatial_consistency_check = all_params[j][6]
    use_overlap_criterion = all_params[j][7]
    cluster_separation_limit = all_params[j][8][0]
    gibbs_separation_limit = all_params[j][8][1]
    pos_3d_adjustment_error_limit = all_params[j][8][2]
    gibbs_improvement_factor = all_params[j][9]
    # -- #
    # Save current params -- #
    with open(params_save_file_path, "w") as f:
        for cpi, cpname in enumerate(param_names):
            f.write("%s: \t %s \n" % (cpname, all_params[j][cpi]))
    # -- #
    t1 = time.time()
    print("Creating Views")
    if views == None:
        views = create_views(data_path, base_img_path, limit=end_view, every_xth_image=step_size,
                             start_v=start_view, text_file=text_file, name_skip=name_skip,
                             use_interpolated_path=use_interpolated_path, bad_images_path=bad_images_path)
    print("%d views created" % len(views))
    t2 = time.time()
    with open(time_save_file_path, "w") as f:
        f.write("Views creation:\t %.2f \n" % (t2-t1))
    print("Creating matches")
    if use_overlap_criterion != 0:
        matches = create_matches(views, use_spatial_consistency_check, use_overlap_criterion, K)
    else:
        matches = create_matches(views, use_spatial_consistency_check)
    t3 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Matches creation:\t %.2f \n" % (t3-t2))
    sfm = SFM(views, matches, K, run_id=run_id, save_path=save_path)
    print("Starting reconstruction")
    sfm.reconstruct()
    sfm.remove_double_mapped_points()
    sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
    sfm.remap_mapped_points()
    print("Reconstruction done")
    t4 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Reconstruction:\t %.2f \n" % (t4-t3))
    # Adjust camera pos with real data shift
    if use_camera_pos_shift:
        for counter_view, view in enumerate(views):
            add_t = (view.R[2, :] * 0.085 + view.R[0, :] * 0.045)[:, None]
            view.t = view.t + (-view.R @ add_t)
    points_3d = sfm.points_3D
    # Reset points to be in front of their corresponding views
    corrected_points = 0
    for val in range(sfm.point_counter):
        if reset_all_points or not sfm.rev_point_map[val][1]:
            corrected_points += 1
            cE = np.hstack((views[sfm.rev_point_map[val][0]].R, views[sfm.rev_point_map[val][0]].t))
            relevant_bounds = np.array([0, 2, 4]) + (cE[2, :3] > 0).astype(int)
            relevant_bounds = bounds_xyz[relevant_bounds]
            relevant_bounds[cE[2, :3] > 0] -= 1
            relevant_bounds[cE[2, :3] <= 0] += bounds_xyz[-2]
            cur_fac = np.min(((relevant_bounds - (np.linalg.inv(-cE[:, :3]) @ cE[:, 3])) / cE[2, :3])[:2])
            points_3d[val] = (np.linalg.inv(-cE[:, :3]) @ cE[:, 3]) + cur_fac*cE[2, :3]
            if points_3d[val][2] < 0:
                points_3d[val][2] = 0.
    t5 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Point preparation :\t %.2f \n" % (t5-t4))
    # Added for separating any points which are still behind their corresponding view --#
    break_cond = 1
    print("Behind separation")
    while break_cond != 0:
        points_3d, break_cond = separate_behind_points(sfm, points_3d, views, bounds_xyz)
        print("Remapped points: %d" % break_cond)
        sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
    sfm.points_3D = points_3d
    sfm.remap_mapped_points()
    points_3d = sfm.points_3D
    t6 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Behind separation:\t %.2f \n" % (t6-t5))
    # -- #
    # Added for separating matches with high error --#
    break_cond = 1
    print("Cluster separation")
    while break_cond != 0:
        points_3d, break_cond = cluster_separate(sfm, points_3d, views, use_bounds=use_bounds,
                                                 bounds_xyz=bounds_xyz,
                                                 cluster_separation_limit=cluster_separation_limit)
        print("Remapped points: %d" % break_cond)
        sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
    sfm.points_3D = points_3d
    sfm.remap_mapped_points()
    points_3d = sfm.points_3D
    t7 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Cluster separation:\t %.2f \n" % (t7-t6))
    # -- #
    # Added for identifying single wrong matches -- #
    print("Gibbs separation")
    gibbs_separate(sfm, points_3d, views, use_bounds=use_bounds, bounds_xyz=bounds_xyz,
                   gibbs_separation_limit=gibbs_separation_limit, gibbs_improvement_factor=gibbs_improvement_factor)
    sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
    sfm.points_3D = points_3d
    sfm.remap_mapped_points()
    points_3d = sfm.points_3D
    t8 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Gibbs separation:\t %.2f \n" % (t8-t7))
    # -- #
    break_cond = 1
    print("3D pos adjustment")
    while break_cond != 0:
        points_3d, break_cond = run_ba_no_E_no_K(sfm, points_3d, views, use_bounds=use_bounds, bounds_xyz=bounds_xyz,
                                                 pos_3d_adjustment_error_limit=pos_3d_adjustment_error_limit)
        print("Removed points: %d" % break_cond)
        sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
    sfm.points_3D = points_3d
    sfm.remap_mapped_points()
    t9 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("3D pos adjustment:\t %.2f \n" % (t9-t8))
    camera_params2 = []
    for iv, view in enumerate(views):
        cur_R = Rot.from_matrix(view.R).as_rotvec()
        cur_t = view.t
        camera_params2.append(np.hstack((cur_R, cur_t.flatten())))
    camera_params2 = np.array(camera_params2)
    # Final adjustment
    if reset_points_for_final_adjustment:
        points_3d = sfm.points_3D
        # Reset points, which are behind the corresponding view to the lowest or highest valued corner
        # depending on which of those is in front of the view
        corrected_points = 0
        for val in range(sfm.point_counter):
            corrected_points += 1
            cE = np.hstack((views[sfm.rev_point_map[val][0]].R, views[sfm.rev_point_map[val][0]].t))
            relevant_bounds = np.array([0, 2, 4]) + (cE[2, :3] > 0).astype(int)
            relevant_bounds = bounds_xyz[relevant_bounds]
            relevant_bounds[cE[2, :3] > 0] -= 1
            relevant_bounds[cE[2, :3] <= 0] += bounds_xyz[-2]
            cur_fac = np.min(((relevant_bounds - (np.linalg.inv(-cE[:, :3]) @ cE[:, 3])) / cE[2, :3])[:2])
            points_3d[val] = (np.linalg.inv(-cE[:, :3]) @ cE[:, 3]) + cur_fac * cE[2, :3]
            if points_3d[val][2] < 0:
                points_3d[val][2] = 0.
    else:
        points_3d = sfm.points_3D
    intrinsic_k = np.array([K[0, 0], K[1, 1], K[0, 2], K[1, 2]])
    t10 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Adjustment all params preparation:\t %.2f \n" % (t10-t9))
    print("Adjust all params")
    break_cond = 1
    start_x0 = np.hstack((camera_params2.ravel()))
    while break_cond != 0:
        camera_params2, points_3d, break_cond = run_ba_final_no_k(sfm, points_3d, camera_params2, views,
                                                                  intrinsic_k, use_bounds=use_bounds,
                                                                  bounds_xyz=bounds_xyz,
                                                                  std_lim=std_lim, bounds_trans=bounds_trans,
                                                                  bounds_rots=bounds_rots, start_x0=start_x0)
        print("Removed points: %d" % break_cond)
        sfm.remove_3d_points_with_one_match(min_k=min_matches_per_point_single)
        if reduce_std_lim_to != 0:
            if break_cond == 0 and std_lim != reduce_std_lim_to:
                std_lim = reduce_std_lim_to
                break_cond = 1
    sfm.points_3D = points_3d
    sfm.remap_mapped_points()
    sfm.plot_points("_ba_all_run_%02d" % j)
    t11 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Adjust all params:\t %.2f \n" % (t11-t10))
    points_2d = []
    camera_indices = []
    point_indices = []
    all_descriptors = []
    sorted_keys = sorted(sfm.point_map.items(), key=lambda x: x[1][0])
    for key, val in sorted_keys:
        camera_indices.append(key[0])
        point_indices.append(val[0])
        points_2d.append(views[key[0]].keypoints[key[1]].pt)
        if save_all_descriptors:
            all_descriptors.append(views[key[0]].descriptors[key[1]])
    all_descriptors = np.array(all_descriptors).astype("int")
    descriptors = np.array([]).reshape(0, 128)
    for cur_d in range(sfm.point_counter):
        descriptors = np.append(descriptors, np.array(sfm.rev_point_map[cur_d][2:]), axis=0)
    np.save(save_path + "/p3D_desc_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), descriptors)
    np.save(save_path + "/p3D_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), sfm.points_3D)
    np.save(save_path + "/p3Dc_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), sfm.points_3D_colors)
    np.save(save_path + "/p2D_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), points_2d)
    np.save(save_path + "/pI_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), point_indices)
    np.save(save_path + "/cI_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), camera_indices)
    np.save(save_path + "/cp_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), camera_params2)
    np.save(save_path + "/K_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), intrinsic_k)
    if save_all_descriptors:
        np.save(save_path + "/p3D_descALL_%d_%d_%d_run_%02d" % (start_view, end_view, step_size, j), all_descriptors)
    t12 = time.time()
    with open(time_save_file_path, "a") as f:
        f.write("Completion time:\t %.2f \n" % (t12-t1))
    print("----Done----")


if __name__ == "__main__":
    cur_runs = np.arange(len(all_params))
    np.random.shuffle(cur_runs)
    print("Cur Process Id: ", cur_process_id)
    print("Number of Runs: ", len(cur_runs))
    print("Cur Runs: ", cur_runs)
    if len(start_views) == 1 and len(end_views) == 1 and len(step_sizes) == 1:
        views = create_views(data_path, base_img_path, limit=end_views[0], every_xth_image=step_sizes[0],
                             start_v=start_views[0], text_file=text_file, name_skip=name_skip,
                             use_interpolated_path=use_interpolated_path, bad_images_path=bad_images_path)
    else:
        views = None
    for cr in cur_runs:
        run_process(cr, views=views)