def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = pts1/M
pts2 = pts2/M
n = pts1.shape[0] #num points
x1 = pts1[:,0]
x2 = pts2[:,0]
y1 = pts1[:,1]
y2 = pts2[:,1]
A = np.vstack([
x2*x1,
x2*y1,
x2,
y2*x1,
y2*y1,
y2,
x1,
y1,
np.ones(n)])
V = np.linalg.svd(np.transpose(A))[2]
F1 = V[-1,:].reshape(3,3)
F2 = V[-2,:].reshape(3,3)
F1 = helper.refineF(F1, pts1, pts2)
F2 = helper.refineF(F2, pts1, pts2)
# given to find coefficients
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = 2*(fun(1) - fun(-1))/3 - (fun(2) - fun(-2))/12
a2 = 0.5*fun(1) + 0.5*fun(-1) - fun(0)
#a3 = (fun(1) - fun(-1))/6 + (fun(2) - fun(-2))/12
a3 = 0.5*(fun(1) - fun(-1)) - a1
coeff = np.array([a3,a2,a1,a0])
alpha = np.polynomial.polynomial.polyroots(coeff)
# extract real solutions
alpha = np.real(alpha[np.isreal(alpha)])
T = np.diag([1.0/M, 1.0/M, 1.0])
Farray = []
for a in alpha:
#a = a.real
F = a*F1 +(1-a)*F2
F = helper._singularize(F)
F = helper.refineF(F, pts1, pts2)
F = np.dot(np.transpose(T), np.dot(F,T))
Farray.append(F)
Farray = np.array(Farray)
np.savez('../results/q2_2.npz', F=F, M=M, pts1=pts1, pts2=pts2)
return Farray
def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = pts1 * 1.0 / M
pts2 = pts2 * 1.0 / M
n, temp = pts1.shape
x1 = pts1[:, 0]
y1 = pts1[:, 1]
x2 = pts2[:, 0]
y2 = pts2[:, 1]
A1 = (x2 * x1)
A2 = (x2 * y1)
A3 = x2
A4 = y2 * x1
A5 = y2 * y1
A6 = y2
A7 = x1
A8 = y1
A9 = np.ones(n)
A = np.vstack((A1, A2, A3, A4, A5, A6, A7, A8, A9))
A = A.T
u, s, vh = np.linalg.svd(A)
f1 = vh[-1, :]
f2 = vh[-2, :]
F1 = f1.reshape(3, 3)
F2 = f2.reshape(3, 3)
F1 = helper.refineF(F1, pts1, pts2)
F2 = helper.refineF(F2, pts1, pts2)
# w = sympy.Symbol('w')
# m = sympy.Matrix(w*F1+(1-w)*F2)
#
# coeff = (m.det().as_poly().coeffs())
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = (fun(1) - fun(-1)) / 3 - (fun(2) - fun(-2)) / 12
a2 = 0.5 * fun(1) + 0.5 * fun(-1) - fun(0)
a3 = (fun(1) - fun(-1)) / 6 + (fun(2) - fun(-2)) / 12
coeff = [a3, a2, a1, a0]
# print(coeff)
# coeff = coeff[::-1]
# print(coeff)
soln = np.roots(coeff)
soln = soln[np.isreal(soln)]
# print(soln)
# print(soln.shape)
Fs = []
T = np.array([[1. / M, 0, 0], [0, 1. / M, 0], [0, 0, 1]])
for i in range(len(soln)):
F = (np.matmul(T.T, np.matmul((soln[i] * F1 + (1 - soln[i]) * F2), T)))
# F = helper.refineF(F,pts1,pts2)
# F = helper._singularize(F)
Fs.append(F)
# print (Fs)
if (os.path.isfile('q2_2.npz') == False):
np.savez('q2_2.npz', F=Fs[2], M=M, pts1=pts1, pts2=pts2)
return Fs
def eightpoint(pts1, pts2, M):
# normalize the coordinates
x1, y1 = pts1[:, 0], pts1[:, 1]
x2, y2 = pts2[:, 0], pts2[:, 1]
x1, y1, x2, y2 = x1 / M, y1 / M, x2 / M, y2 / M
# normalization matrix
T = np.array([[1. / M, 0, 0], [0, 1. / M, 0], [0, 0, 1]])
A = np.transpose(
np.vstack((x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1,
np.ones(x1.shape))))
# get F by SVD decomposition
u, s, vh = np.linalg.svd(A)
f = vh[-1, :]
F = np.reshape(f, (3, 3))
# refine F
F = helper.refineF(F, pts1 / M, pts2 / M)
# constraint of rank 2 by setting the last singular value to 0
F = helper._singularize(F)
# rescale the data
F = np.dot(np.transpose(T), np.dot(F, T))
return F
def eightpoint(pts1, pts2, M):
#making a scaling T matrix
T=np.zeros((3,3))
T[0][0]=1/M
T[1][1]=1/M
T[2][2]=1
#number of correspondences
n=pts1.shape[0]
A=np.zeros((n,9))
#normalizing the matrix
pts1=pts1/M
pts2=pts2/M
#creating the a matrix
A[:,0]=np.multiply(pts1[:,0],pts2[:,0])
A[:,1]=np.multiply(pts1[:,0],pts2[:,1])
A[:,2]=pts1[:,0]
A[:,3]=np.multiply(pts1[:,1],pts2[:,0])
A[:,4]=np.multiply(pts1[:,1],pts2[:,1])
A[:,5]=pts1[:,1]
A[:,6]=pts2[:,0]
A[:,7]=pts2[:,1]
A[:,8]=np.ones(n)
#svd and reshaping fundamental matrix
U,S,V=np.linalg.svd(A)
F=np.transpose(V[-1,:]).reshape(3,3)
#singulairy function
F=_singularize(F)
#refine
F=refineF(F,pts1,pts2)
#unnormalize the matrix
mat=np.matmul(T.transpose(),F)
F=np.matmul(mat,T)
#np.savez('/home/geekerlink/Desktop/Computer Vision/Homeworks/hw4/hw4/results/q2_1.npz',F=F,M=M)
return F
def eightpoint(pts1, pts2, M):
pts1 = pts1 / M
pts2 = pts2 / M
u = pts1[:, 0]
u1 = pts2[:, 0]
v = pts1[:, 1]
v1 = pts2[:, 1]
# Construction A matrix
A = np.vstack(
[u * u1, v * u1, u1, u * v1, v * v1, v1, u, v,
np.ones(u.shape)])
# Get eigenvector
_, _, V = np.linalg.svd(A.T)
F = np.reshape(V[-1, :], (3, 3))
# Local minimization
from helper import refineF
F = refineF(F, pts1, pts2)
# Unscale F using T representing scaling by 1/M
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
unscaledF = np.dot(np.dot(np.transpose(T), F), T)
return unscaledF
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
normPts1 = pts1 / M
normPts2 = pts2 / M
pts1Y = normPts1[:, 1]
pts1X = normPts1[:, 0]
pts2Y = normPts2[:, 1]
pts2X = normPts2[:, 0]
AMat = np.ones([np.size(pts1X), 9])
AMat[:, 0] = np.multiply(pts2X, pts1X)
AMat[:, 1] = np.multiply(pts2X, pts1Y)
AMat[:, 2] = pts2X
AMat[:, 3] = np.multiply(pts2Y, pts1X)
AMat[:, 4] = np.multiply(pts2Y, pts1Y)
AMat[:, 5] = pts2Y
AMat[:, 6] = pts1X
AMat[:, 7] = pts1Y
U, S, Vt = np.linalg.svd(AMat)
VNormal = np.transpose(Vt)
Fiter1 = VNormal[:, -1]
Fiter1Res = np.reshape(Fiter1, (3, 3))
Unew, Snew, Vtnew = np.linalg.svd(Fiter1Res)
Snew[-1] = 0
SMat = np.diag(Snew)
Fiter2 = np.matmul(np.matmul(Unew, SMat), Vtnew)
#print (Fiter2)
Fscaled = helper.refineF(Fiter2, normPts1, normPts2)
TMat = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
Funscaled = np.matmul(np.matmul(TMat, Fscaled), TMat)
return Funscaled
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
# Normalizing
pts1 = pts1 / M
pts2 = pts2 / M
W = help_func(pts1, pts2)
u, s, vh = np.linalg.svd(W)
eigen_value = vh[-1, :]
eigen_value = eigen_value.reshape(3, 3)
F = helper._singularize(eigen_value)
F = helper.refineF(F, pts1, pts2)
M_list = [[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]]
T_matrix = np.asarray(M_list)
F = np.matmul(T_matrix.T, np.matmul(F, T_matrix))
np.savez('q2_1.npz', F=F, M=M)
return F
def sevenpoint(pts1, pts2, M):
# normalize the coordinates
x1, y1 = pts1[:, 0], pts1[:, 1]
x2, y2 = pts2[:, 0], pts2[:, 1]
x1, y1, x2, y2 = x1 / M, y1 / M, x2 / M, y2 / M
# normalization matrix
T = np.array([[1. / M, 0, 0], [0, 1. / M, 0], [0, 0, 1]])
A = np.transpose(
np.vstack((x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1,
np.ones(x1.shape))))
# get F by SVD decomposition
u, s, vh = np.linalg.svd(A)
f1 = vh[-1, :]
f2 = vh[-2, :]
F1 = np.reshape(f1, (3, 3))
F2 = np.reshape(f2, (3, 3))
fun = lambda alpha: np.linalg.det(alpha * F1 + (1 - alpha) * F2)
# get the coefficients of the polynomial
a0 = fun(0)
a1 = 2 * (fun(1) - fun(-1)) / 3 - (fun(2) - fun(-2)) / 12
a2 = (fun(1) + fun(-1)) / 2 - a0
a3 = (fun(1) - fun(-1)) / 2 - a1
# solve for alpha
alpha = np.roots([a3, a2, a1, a0])
Farray = [a * F1 + (1 - a) * F2 for a in alpha]
# refine F
Farray = [helper.refineF(F, pts1 / M, pts2 / M) for F in Farray]
# denormalize F
Farray = [np.dot(np.transpose(T), np.dot(F, T)) for F in Farray]
return Farray
def sevenpoint(pts1, pts2, M):
pts1 = pts1.astype('float64')
pts2 = pts2.astype('float64')
pts1 /= M
pts2 /= M
A = [pts2[:,0]*pts1[:,0], pts2[:,0]*pts1[:,1], pts2[:,0], pts2[:,1]*pts1[:,0], pts2[:,1]*pts1[:,1], pts2[:,1], pts1[:,0], pts1[:,1], np.ones_like(pts1[:,0])]
A = np.asarray(A).T
U, S, V = np.linalg.svd(A)
F1 = V[-1].reshape(3,3)
F2 = V[-2].reshape(3,3)
func = lambda x: np.linalg.det((x * F1) + ((1 - x) * F2))
x0 = func(0)
x1 = (2 * (func(1) - func(-1)) / 3.0) - ((func(2) - func(-2)) / 12.0)
x2 = (0.5 * func(1)) + (0.5 * func(-1)) - func(0)
x3 = func(1) - x0 - x1 - x2
alphas = np.roots([x3,x2,x1,x0])
alphas = np.real(alphas[np.isreal(alphas)])
final_F = []
for a in alphas:
F = (a * F1) + ((1 - a) * F2)
F = refineF(F, pts1, pts2)
t = np.array([[1.0/M,0.0,0.0],[0.0,1.0/M,0.0],[0.0,0.0,1.0]])
F = t.T.dot(F).dot(t)
final_F.append(F)
# np.savez('q2_2.npz', F=final_F[-1], M=M, pts1=pts1, pts2=pts2)
return final_F
def sevenpoint(pts1, pts2, M):
pts1 = pts1 / M
pts2 = pts2 / M
A = [pts2[:,0]*pts1[:,0], pts2[:,0]*pts1[:,1], pts2[:,0], pts2[:,1]*pts1[:,0], \
pts2[:,1]*pts1[:,1], pts2[:,1], pts1[:,0], pts1[:,1], np.ones_like(pts1[:,0])]
A = np.asarray(A).T
u, s, v = np.linalg.svd(A)
F1 = v[-1].reshape(3, 3)
F2 = v[-2].reshape(3, 3)
# use the property of determinant
det = lambda x: np.linalg.det((x * F1) + ((1 - x) * F2))
a0 = det(0)
a1 = (2 * (det(1) - det(-1)) / 3.0) - ((det(2) - det(-2)) / 12.0)
a2 = (0.5 * det(1)) + (0.5 * det(-1)) - det(0)
a3 = det(1) - a0 - a1 - a2
alphas = np.roots([a3, a2, a1, a0])
alphas = np.real(alphas[np.isreal(alphas)])
Fs = []
for a in alphas:
F = a * F1 + (1 - a) * F2
u, s, vh = np.linalg.svd(np.array(F))
s[2] = 0
F = u @ np.diag(s) @ vh
F = helper.refineF(F, pts1, pts2)
T = np.diag((1 / M, 1 / M, 1))
F = T.T @ F @ T
Fs.append(F)
Fs = np.array(Fs)
# uncomment this to save F
# np.savez('q2_2.npz', F=final, M=M, pts1=pts1, pts2=pts2)
return Fs
def eightpoint(pts1, pts2, M):
pts1 = pts1 / M
pts2 = pts2 / M
x1 = pts1[:, 0]
y1 = pts1[:, 1]
x2 = pts2[:, 0]
y2 = pts2[:, 1]
# SVD solve AF=0
A = np.stack(
[x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1,
np.ones(len(x1))],
axis=1)
(U, S, V) = np.linalg.svd(A)
V = np.transpose(V)
F = np.reshape(V[:, len(V) - 1], (3, 3))
# enforce the singularity condition of the F before unscaling Set rank=2
[U1, S1, V1] = np.linalg.svd(F)
S1[2] = 0
F = np.dot(U1, np.diag(S1))
F = np.dot(F, V1)
# refine F before unscaling F
F = helper.refineF(F, pts1, pts2)
# unscaling F
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
F = np.dot(np.transpose(T), F).dot(T)
# np.savez('../jingruwu/data/q2_1.npz', F=F, M=M)
return F
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
# pass
pts1_norm = pts1 / M
pts2_norm = pts2 / M
pts1_x, pts1_y = pts1_norm[:, 0], pts1_norm[:, 1]
pts2_x, pts2_y = pts2_norm[:, 0], pts2_norm[:, 1]
solve_A = np.ones([np.size(pts1_x), 9])
solve_A[:, 0] = np.multiply(pts2_x, pts1_x)
solve_A[:, 1] = np.multiply(pts2_x, pts1_y)
solve_A[:, 2] = pts2_x
solve_A[:, 3] = np.multiply(pts2_y, pts1_x)
solve_A[:, 4] = np.multiply(pts2_y, pts1_y)
solve_A[:, 5] = pts2_y
solve_A[:, 6] = pts1_x
solve_A[:, 7] = pts1_y
U, S, Vt = np.linalg.svd(solve_A)
V = np.transpose(Vt)
F_svd1 = np.reshape(V[:, -1], (3, 3))
F_singular = helper._singularize(F_svd1)
refined_F = helper.refineF(F_singular, pts1_norm, pts2_norm)
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
result = T @ refined_F @ T
return result
def eightpoint(pts1, pts2, M):
T = np.array(([1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]))
pts1_n = [np.dot(T, np.insert(pt1, 2, 1)).T for pt1 in pts1]
pts2_n = [np.dot(T, np.insert(pt2, 2, 1)).T for pt2 in pts2]
U = []
for i in range(pts1.shape[0]):
a = [
pts1_n[i][0] * pts2_n[i][0], pts1_n[i][1] * pts2_n[i][0],
pts2_n[i][0], pts1_n[i][0] * pts2_n[i][1],
pts1_n[i][1] * pts2_n[i][1], pts2_n[i][1], pts1_n[i][0],
pts1_n[i][1], 1
]
U.append(a)
U = np.vstack(U)
u, s, v = np.linalg.svd(U)
F = v[-1].reshape(3, 3)
pts1_n = np.array(pts1_n)
pts2_n = np.array(pts2_n)
pts1_n = np.delete(pts1_n, -1, axis=1)
pts2_n = np.delete(pts2_n, -1, axis=1)
F = hp.refineF(F, np.array(pts1_n), np.array(pts2_n))
F = np.dot(T.T, np.dot(F, T))
return F
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = np.divide(pts1, M)
pts2 = np.divide(pts2, M)
N = pts1.shape[0]
pts1_x = pts1[:, 0]
pts1_y = pts1[:, 1]
pts2_x = pts2[:, 0]
pts2_y = pts2[:, 1]
A = np.vstack(
(np.multiply(pts1_x, pts2_x), np.multiply(pts1_x, pts2_y), pts1_x,
np.multiply(pts1_y, pts2_x), np.multiply(pts1_y, pts2_y), pts1_y,
pts2_x, pts2_y, np.ones(N)))
A = A.T
u, s, v = np.linalg.svd(A)
F = np.reshape(v[8, :], (3, 3))
F_refined = hp.refineF(F, pts1, pts2)
t = 1.0 / M
T = np.array([[t, 0, 0], [0, t, 0], [0, 0, 1]])
F = np.matmul(T.T, np.matmul(F_refined, T))
return F
def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1_scaled = pts1 / M
pts2_scaled = pts2 / M
A_f = np.zeros((pts1_scaled.shape[0], 9))
for i in range(pts1_scaled.shape[0]):
A_f[i, :] = [
pts2_scaled[i, 0] * pts1_scaled[i, 0],
pts2_scaled[i, 0] * pts1_scaled[i, 1], pts2_scaled[i, 0],
pts2_scaled[i, 1] * pts1_scaled[i, 0],
pts2_scaled[i, 1] * pts1_scaled[i, 1], pts2_scaled[i, 1],
pts1_scaled[i, 0], pts1_scaled[i, 1], 1
]
# print('A: ', A_f)
# print('A shape: ', A_f.shape)
u, s, vh = np.linalg.svd(A_f)
v = vh.T
f1 = v[:, -1].reshape(3, 3)
f2 = v[:, -2].reshape(3, 3)
fun = lambda a: np.linalg.det(a * f1 + (1 - a) * f2)
a0 = fun(0)
a1 = (2 / 3) * (fun(1) - fun(-1)) - ((fun(2) - fun(-2)) / 12)
a2 = 0.5 * fun(1) + 0.5 * fun(-1) - fun(0)
a3 = (-1 / 6) * (fun(1) - fun(-1)) + (fun(2) - fun(-2)) / 12
coeff = [a3, a2, a1, a0]
# coeff = [a0, a1, a2, a3] // WRONG
roots = np.roots(coeff)
# print('roots: ', roots)
T = np.diag([1 / M, 1 / M, 1])
F_list = np.zeros((3, 3, 1))
for root in roots:
if np.isreal(root):
a = np.real(root)
F = a * f1 + (1 - a) * f2
# F = refineF(F, pts1_scaled, pts2_scaled)
unscaled_F = T.T.dot(F).dot(T)
if np.linalg.matrix_rank(unscaled_F) == 3:
print(
'---------------------------------------------------------------------------'
)
F = refineF(F, pts1_scaled, pts2_scaled)
unscaled_F = F
F_list = np.dstack((F_list, unscaled_F))
F_list = F_list[:, :, 1:]
# print('F_list shape: ', F_list.shape)
return F_list
def eightpoint(pts1, pts2, M):
# Scale the correspondence
A = np.empty((pts1.shape[0], 9))
pts1 = pts1 / M
pts2 = pts2 / M
x1 = pts1[:, 0]
y1 = pts1[:, 1]
x2 = pts2[:, 0]
y2 = pts2[:, 1]
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
# Construct A matrix
A = np.vstack((x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1,
np.ones(pts1.shape[0]))).T
u, s, vh = np.linalg.svd(A) # Find SVD of AtA
F = vh[-1].reshape(
3, 3
) # Fundamental Matrix is column corresponding to the least singular values
F = helper.refineF(F, pts1, pts2) # Refine F by using local minimization
# Enforce rank2 constraint a.k.a singularity condition
F = helper._singularize(F)
# Unscale the fundamental matrix
F = np.dot((np.dot(T.T, F)), T)
return F
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = pts1 * 1.0 / M
pts2 = pts2 * 1.0 / M
n, temp = pts1.shape
x1 = pts1[:, 0]
y1 = pts1[:, 1]
x2 = pts2[:, 0]
y2 = pts2[:, 1]
A1 = (x2 * x1)
# print(A1.shape)
A2 = (x2 * y1)
A3 = x2
A4 = y2 * x1
A5 = y2 * y1
A6 = y2
A7 = x1
A8 = y1
A9 = np.ones(n)
A = np.vstack((A1, A2, A3, A4, A5, A6, A7, A8, A9))
A = A.T
u, s, vh = np.linalg.svd(A)
f = vh[-1, :]
F = f.reshape(3, 3)
F = helper._singularize(F)
F = helper.refineF(F, pts1, pts2)
T = np.array([[1. / M, 0, 0], [0, 1. / M, 0], [0, 0, 1]])
F = np.matmul(T.T, np.matmul(F, T))
# print(F)
if (os.path.isfile('q2_1.npz') == False):
np.savez('q2_1.npz', F=F, M=M)
return F
def eightpoint(p1, p2, M): # inverse p1 & p2 ??
assert (p1.shape[0] == p2.shape[0])
assert (p1.shape[1] == 2)
#review this
p1 = p1 / M
p2 = p2 / M
# todo: relation between p1 and p2
n = p1.shape[0]
A = np.zeros((n, 9))
A[0:n, 0] = p2[:, 0] * p1[:, 0]
A[0:n, 1] = p2[:, 0] * p1[:, 1]
A[0:n, 2] = p2[:, 0]
A[0:n, 3] = p2[:, 1] * p1[:, 0]
A[0:n, 4] = p2[:, 1] * p1[:, 1]
A[0:n, 5] = p2[:, 1]
A[0:n, 6] = p1[:, 0]
A[0:n, 7] = p1[:, 1]
A[0:n, 8] = 1
u, s, vh = np.linalg.svd(np.array(A))
F = vh[-1].reshape(3, 3)
u, s, vh = np.linalg.svd(np.array(F))
s[2] = 0
F = u @ np.diag(s) @ vh
F = helper.refineF(F, p1, p2)
T = np.diag((1 / M, 1 / M, 1))
F = T.T @ F @ T
# np.savez('q2_1.npz', F=F, M=M) # resave this
return F
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
x1 = pts1[:, 0] / M
y1 = pts1[:, 1] / M
x1_ = pts2[:, 0] / M
y1_ = pts2[:, 1] / M
U = np.vstack((x1 * x1_, y1 * x1_, x1_, x1 * y1_, y1 * y1_, y1_, x1, y1,
np.ones((x1.shape[0]))))
V = np.matmul(U, np.transpose(U))
w, v = np.linalg.eig(V)
e_vals, e_vecs = np.linalg.eig(V)
F = e_vecs[:, np.argmin(e_vals)]
F = np.reshape(F, (3, 3))
F = helper.refineF(F, pts1 / M, pts2 / M)
F = np.transpose(T) @ F @ T
return F
def eightpoint(pts1, pts2, M):
M = float(M)
pts1 = pts1 / M
pts2 = pts2 / M
# curate A matrix
A = np.zeros((len(pts1), 9))
A[:, 0] = pts1[:, 0] * pts2[:, 0]
A[:, 1] = pts1[:, 0] * pts2[:, 1]
A[:, 2] = pts1[:, 0]
A[:, 3] = pts1[:, 1] * pts2[:, 0]
A[:, 4] = pts1[:, 1] * pts2[:, 1]
A[:, 5] = pts1[:, 1]
A[:, 6] = pts2[:, 0]
A[:, 7] = pts2[:, 1]
A[:, 8] = np.ones(len(pts1))
# perform SVD, the last row of V is the eigen vector corresponding to the least eigen value
S, D, V = np.linalg.svd(A)
F = V[-1].reshape(3, 3)
# enforce the singularity condition
F = helper._singularize(F)
F = helper.refineF(F, pts1, pts2)
# unscale the fundamental matrix
T = np.diag((1.0 / M, 1.0 / M, 1.0))
F = (np.transpose(T).dot(F)).dot(T)
np.savez('../results/q2_1.npz', F=F, M=M)
return F
def sevenpoint(pts1, pts2, M):
#Normalizing
pts1 = pts1/M
pts2 = pts2/M
# List of F matrices
Farray = []
# Forming matrix A
A = np.zeros([7, 9])
for i in range(7):
A[i,0] = pts2[i][0]*pts1[i][0]
A[i,1] = pts2[i][0]*pts1[i][1]
A[i,2] = pts2[i][0]
A[i,3] = pts2[i][1]*pts1[i][0]
A[i,4] = pts2[i][1]*pts1[i][1]
A[i,5] = pts2[i][1]
A[i,6] = pts1[i][0]
A[i,7] = pts1[i][1]
A[i,8] = 1
# print (A.shape)
u,s,vT = np.linalg.svd(A)
v = vT.T
v1 = v[:,-1]
v2 = v[:,-2]
F1 = v1.reshape(3,3)
F2 = v2.reshape(3,3)
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = 2/3*(fun(1)-fun(-1))-(fun(2)-fun(-2))/12
a2 = 0.5*fun(1)+0.5*fun(-1)-fun(0)
a3 = (fun(1)-fun(-1))/2 - a1
coeff = [a3, a2, a1, a0]
# print (coeff)
a = np.roots(coeff)
number_roots = 3
for i in range(3):
if isinstance(a[i], complex):
number_roots = 1
T = np.array([[1/M, 0, 0], [0, 1/M, 0],[0,0,1]])
a1 = T.T
for k in range(number_roots):
temp = a[k] * F1 + (1 - a[k]) * F2
Farray.append(temp)
Farray[k] = helper.refineF(Farray[k],pts1,pts2)
# #Unnormalizing
Farray[k] = np.real(np.matmul(np.matmul(a1, Farray[k]),T))
return Farray
def eightpoint(pts1, pts2, M):
x1, y1, x2, y2 = pts1[:, 0] / M, pts1[:, 1] / M, pts2[:, 0] / M, pts2[:, 1] / M
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
A = np.vstack((x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1, np.ones(x1.shape))).T
_, _, vh = np.linalg.svd(A)
F = vh[-1, :].reshape(3, 3)
F = helper.refineF(F, pts1 / M, pts2 / M)
F = helper._singularize(F)
F = np.dot(np.dot(T.T, F), T)
return F
def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = pts1 / M
pts2 = pts2 / M
W = help_func(pts1, pts2)
u, s, vh = np.linalg.svd(W)
e1 = vh[-1, :]
e2 = vh[-2, :]
e1 = e1.reshape(3, 3)
e2 = e2.reshape(3, 3)
F1 = helper.refineF(e1, pts1, pts2)
F2 = helper.refineF(e2, pts1, pts2)
def det(alpha):
out = np.linalg.det(alpha * F1 + (1 - alpha) * F2)
return out
res1 = det(0)
res2 = 2 * (det(1) - det(-1)) / 3 - (det(2) - det(-2)) / 12
res3 = 0.5 * (det(1)) + 0.5 * (det(-1) - det(0))
res4 = det(1) - res1 - res2 - res3
res = [res4, res3, res2, res1]
M_list = [[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]]
T_matrix = np.asarray(M_list)
roots = np.roots(res)
Fstack = []
for alpha in roots:
if np.isreal(alpha) == True:
new_F = alpha * F1 + (1 - alpha) * F2
F = np.matmul(T_matrix.T, np.matmul(new_F, T_matrix))
Fstack.append(F)
return Fstack
def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
pts1 = np.divide(pts1, M)
pts2 = np.divide(pts2, M)
N = pts1.shape[0]
pts1_x = pts1[:, 0]
pts1_y = pts1[:, 1]
pts2_x = pts2[:, 0]
pts2_y = pts2[:, 1]
A = np.vstack(
(np.multiply(pts1_x, pts2_x), np.multiply(pts1_x, pts2_y), pts1_x,
np.multiply(pts1_y, pts2_x), np.multiply(pts1_y, pts2_y), pts1_y,
pts2_x, pts2_y, np.ones(N)))
A = A.T
u, s, v = np.linalg.svd(A)
f1 = v[8, :]
f2 = v[7, :]
F1 = np.reshape(f1, (3, 3))
F2 = np.reshape(f2, (3, 3))
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = (2 * (fun(1) - fun(-1)) / 3.0) - ((fun(2) - fun(-2)) / 12.0)
a2 = ((fun(1) + fun(-1)) / 2.0) - fun(0)
a3 = ((fun(1) - fun(-1)) / 2.0) - a1
coeff = np.array([a3, a2, a1, a0])
roots = np.roots(coeff)
t = 1.0 / M
T = np.array([[t, 0, 0], [0, t, 0], [0, 0, 1]])
Farray = []
for i in range(0, len(roots)):
x = roots[i]
if x.imag == 0:
x = x.real
F = x * F1 + (1 - x) * F2
F_refined = hp.refineF(F, pts1, pts2)
F = np.matmul(T.T, np.matmul(F_refined, T))
Farray.append(F)
else:
continue
Farray = np.stack(Farray, axis=-1)
return Farray
def sevenpoint(pts1, pts2, M):
'''
Q2.2: Seven Point Algorithm
Input: pts1, Nx2 Matrix
pts2, Nx2 Matrix
M, a scalar parameter computed as max (imwidth, imheight)
Output: Farray, a list of estimated fundamental matrix.
'''
T = np.array(([1/M,0,0],[0,1/M,0],[0,0,1]))
pts1_n = [np.dot(T,np.insert(pt1,2,1)).T for pt1 in pts1]
pts2_n = [np.dot(T,np.insert(pt2,2,1)).T for pt2 in pts2]
U = []
for i in range(pts1.shape[0]):
a = [pts1_n[i][0]*pts2_n[i][0],pts1_n[i][1]*pts2_n[i][0],pts2_n[i][0],pts1_n[i][0]*pts2_n[i][1],pts1_n[i][1]*pts2_n[i][1],pts2_n[i][1],pts1_n[i][0],pts1_n[i][1],1]
U.append(a)
U = np.vstack(U)
u, s, v = np.linalg.svd(U)
F1 = v[-1].reshape(3,3)
F2 = v[-2].reshape(3,3)
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = 2*(fun(1)-fun(-1))/3-(fun(2)-fun(-2))/12
a2 = 0.5*fun(1)+0.5*fun(-1)-fun(0)
a3 = ((fun(2)-fun(-2))-(2*(fun(1)-fun(-1))))/12
roots = np.roots([a3,a2,a1,a0])
F = (1-roots[0]*F1) + (roots[0]*F2)
pts1_n = np.array(pts1_n)
pts2_n = np.array(pts2_n)
pts1_n = np.delete(pts1_n,-1,axis=1)
pts2_n = np.delete(pts2_n,-1,axis=1)
F = hp.refineF(F,np.array(pts1_n),np.array(pts2_n))
F = np.dot(T.T,np.dot(F,T))
return F
def sevenpoint(pts1, pts2, M):
x1, y1, x2, y2 = pts1[:, 0] / M, pts1[:, 1] / M, pts2[:, 0] / M, pts2[:, 1] / M
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
A = np.vstack((x2 * x1, x2 * y1, x2, y2 * x1, y2 * y1, y2, x1, y1, np.ones(x1.shape))).T
_, _, vh = np.linalg.svd(A)
F1 = vh[-1, :].reshape(3, 3)
F2 = vh[-2, :].reshape(3, 3)
a0 = solution(0.0, F1, F2)
a1 = 2.0 * (solution(1.0, F1, F2) - solution(-1.0, F1, F2)) / 3.0 - (solution(2.0, F1, F2) - solution(-2.0, F1, F2)) / 12.0
a2 = (solution(1.0, F1, F2) + solution(-1.0, F1, F2)) / 2.0 - a0
a3 = (solution(1.0, F1, F2) - solution(-1.0, F1, F2)) / 2.0 - a1
alphas = np.roots(np.array([a3, a2, a1, a0]))
Farray = [alpha * F1 + (1 - alpha) * F2 for alpha in alphas]
Farray = [helper.refineF(F, pts1 / M, pts2 / M) for F in Farray]
Farray = [np.dot(np.dot(T.T, F), T) for F in Farray]
return Farray
def eightpoint(pts1, pts2, M):
#TODO :: check if 1 and 2 are not inversed!
#normalize pts1 and pts2
# mean_pt1 = findCenter(pts1)
# mean_pt2 = findCenter(pts2)
# T1 = np.eye(3)
# T2 = np.eye(3)
# T1[0] = [1 / M, 0, -mean_pt1[0] / M]
# T1[1] = [0, 1 / M, -mean_pt1[1] / M]
# T2[0] = [1 / M, 0, -mean_pt2[0] / M]
# T2[1] = [0, 1 / M, -mean_pt2[1] / M]
TT = np.eye(3)
TT[0] = [2 / M, 0, -1]
TT[1] = [0, 2/M, -1]
pts1_norm = TT @ np.vstack((pts1.T,np.ones(pts1.shape[0]))) #dim: 3 x N
pts2_norm = TT @ np.vstack((pts2.T,np.ones(pts2.shape[0]))) #dim: 3 x N
# eight point algorithm
N = pts1.shape[0]
U = np.ones((N,9))
x1 = pts1_norm[0,:]
y1 = pts1_norm[1,:]
x2 = pts2_norm[0,:]
y2 = pts2_norm[1,:]
U[:,0] = x1*x2
U[:,1] = x1*y2
U[:,2] = x1
U[:,3] = y1*x2
U[:,4] = y1*y2
U[:,5] = y1
U[:,6] = x2
U[:,7] = y2
_,_,vh = np.linalg.svd(U)
f = np.reshape(vh[8],(3,3))
F = (1 / f[-1,-1]) * f #not sure if we need to normalized
#enforce singularity condition
F = refineF(F, pts1_norm[:2].T, pts2_norm[:2].T)
F = _singularize(F)
F = TT.T @ F @ TT
return F
def eightpoint(pts1, pts2, M):
pts1 = pts1.astype('float64')
pts2 = pts2.astype('float64')
pts1 /= M
pts2 /= M
A = [pts2[:,0]*pts1[:,0], pts2[:,0]*pts1[:,1], pts2[:,0], pts2[:,1]*pts1[:,0], pts2[:,1]*pts1[:,1], pts2[:,1], pts1[:,0], pts1[:,1], np.ones_like(pts1[:,0])]
A = np.asarray(A).T
U, S, V = np.linalg.svd(A)
F = V[-1].reshape(3,3)
U, S, V = np.linalg.svd(F)
S[-1] = 0.0
F = U.dot(np.diag(S)).dot(V)
F = refineF(F, pts1, pts2)
t = np.array([[1.0/M,0.0,0.0],[0.0,1.0/M,0.0],[0.0,0.0,1.0]])
F = t.T.dot(F).dot(t)
# np.savez('q2_1.npz', F=F, M=M)
return F
def sevenpoint(pts1, pts2, M):
T = np.array(([1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]))
pts1_n = [np.dot(T, np.insert(pt1, 2, 1)).T for pt1 in pts1]
pts2_n = [np.dot(T, np.insert(pt2, 2, 1)).T for pt2 in pts2]
U = []
for i in range(pts1.shape[0]):
a = [
pts1_n[i][0] * pts2_n[i][0], pts1_n[i][1] * pts2_n[i][0],
pts2_n[i][0], pts1_n[i][0] * pts2_n[i][1],
pts1_n[i][1] * pts2_n[i][1], pts2_n[i][1], pts1_n[i][0],
pts1_n[i][1], 1
]
U.append(a)
U = np.vstack(U)
u, s, v = np.linalg.svd(U)
F1 = v[-1].reshape(3, 3)
F2 = v[-2].reshape(3, 3)
fun = lambda a: np.linalg.det(a * F1 + (1 - a) * F2)
a0 = fun(0)
a1 = 2 * (fun(1) - fun(-1)) / 3 - (fun(2) - fun(-2)) / 12
a2 = 0.5 * fun(1) + 0.5 * fun(-1) - fun(0)
a3 = ((fun(2) - fun(-2)) - (2 * (fun(1) - fun(-1)))) / 12
roots = np.roots([a3, a2, a1, a0])
F = (1 - roots[0] * F1) + (roots[0] * F2)
pts1_n = np.array(pts1_n)
pts2_n = np.array(pts2_n)
pts1_n = np.delete(pts1_n, -1, axis=1)
pts2_n = np.delete(pts2_n, -1, axis=1)
F = hp.refineF(F, np.array(pts1_n), np.array(pts2_n))
F = np.dot(T.T, np.dot(F, T))
return F
def sevenpoint(pts1, pts2, M):
# Replace pass by your implementation
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
x1 = pts1[:, 0] / M
y1 = pts1[:, 1] / M
x1_ = pts2[:, 0] / M
y1_ = pts2[:, 1] / M
U = np.vstack((x1 * x1_, y1 * x1_, x1_, x1 * y1_, y1 * y1_, y1_, x1, y1,
np.ones((x1.shape[0]))))
u, s, v = np.linalg.svd(U.T)
f1 = v[8, :]
f2 = v[7, :]
F1 = np.reshape(f1, (3, 3))
F2 = np.reshape(f2, (3, 3))
l = symbols('l')
F = (l) * F1 + (1 - l) * F2
F_ = sympy.Matrix(F)
eq = F_.det()
roots = solve(eq)
roots = np.fromiter(roots, dtype=complex)
Farray = []
for i in range(0, len(roots)):
x = roots[i]
if x.imag == 0:
x = x.real
F = x * F1 + (1 - x) * F2
F = helper.refineF(F, pts1 / M, pts2 / M)
F = np.transpose(T) @ F @ T
Farray.append(F)
Farray = np.array(Farray)
return Farray
