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(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):
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 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):
# 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 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 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):
# 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 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 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 sevenpoint(pts1, pts2, M):
#pts1 and pts2 are 7 x 2
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
# seven 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)
f1 = np.reshape(vh[-1],(3,3))
f2 = np.reshape(vh[-2],(3,3))
func = lambda x: np.linalg.det((1-x) * f1 + x * f2)
d = func(0)
c = 2 * (func(1) - func(-1)) / 3 - (func(2) - func(-2)) / 12
b = (func(1) + func(-1)) / 2 - d
a = (func(1) - func(-1)) / 2 - c
x = np.roots([a, b, c, d])
Fs = [(1 - x_) * f1 + x_ * f2 for x_ in x]
Fs = [refineF(F, pts1_norm[:2].T, pts2_norm[:2].T) for F in Fs]
Fs = [_singularize(F) for F in Fs]
Fs = [TT.T @ F @ TT for F in Fs]
return Fs
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
pts1 = pts1 / M
pts2 = pts2 / M
A = []
for i in range(pts1.shape[0]):
A.append(
np.array([
pts1[i][0] * pts2[i][0], pts1[i][0] * pts2[i][1], pts1[i][0],
pts1[i][1] * pts2[i][0], pts1[i][1] * pts2[i][1], pts1[i][1],
pts2[i][0], pts2[i][1], 1
]))
A = np.vstack(A)
_, _, v = np.linalg.svd(A)
F = v[-1, :].reshape(3, 3)
F = helper._singularize(helper.refineF(F, pts1, pts2))
unnormalized_F = np.dot(np.dot(T.T, F), T)
return unnormalized_F
def sevenpoint(pts1, pts2, M, refine=True):
assert (pts1.shape[0] == 7)
assert (pts1.shape[0] == pts2.shape[0])
# Normalize points
p1 = pts1/M
p2 = pts2/M
T = np.diag([1/M, 1/M, 1])
# Create A matrix
A = np.vstack([p2[:, 0]*p1[:, 0], p2[:, 0]*p1[:, 1], p2[:, 0],
p2[:, 1]*p1[:, 0], p2[:, 1]*p1[:, 1], p2[:, 1],
p1[:, 0], p1[:, 1], np.ones(p1.shape[0])])
U, S, V = np.linalg.svd(A.T)
F1 = V[-1, :].reshape(3, 3)
F2 = V[-2, :].reshape(3, 3)
# 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(2) - fun(-2))/12 - (fun(1) - fun(-1))/6
# Find roots of the polynomial
roots = np.roots([a3, a2, a1, a0])
roots = np.real(roots[np.isreal(roots)])
Farray = []
for a in roots:
F = a*F1 + (1 - a)*F2
if refine:
F = helper._singularize(F) # Singularize
F = helper.refineF(F, p1, p2) # Refine F
F = T.T @ F @ T # Denormalize F
Farray.append(F)
return Farray
def eightpoint(pts1, pts2, M):
assert(pts1.shape[0] >= 8)
assert(pts1.shape[0] == pts2.shape[0])
# Normalize points
p1 = pts1/M
p2 = pts2/M
T = np.diag([1/M, 1/M, 1])
# Create A matrix
A = np.vstack([p1[:, 0]*p2[:, 0], p1[:, 0]*p2[:, 1], p1[:, 0],
p1[:, 1]*p2[:, 0], p1[:, 1]*p2[:, 1], p1[:, 1],
p2[:, 0], p2[:, 1], np.ones(p1.shape[0])])
U, S, V = np.linalg.svd(A.T)
F = V[-1, :].reshape(3, 3)
F = helper._singularize(F) # Singularize
F = helper.refineF(F, p1, p2) # Refine F
F = T.T @ F @ T # Denormalize F
return F
def eightpoint(pts1, pts2, M):
x1 = pts1[:, 0] / M
y1 = pts1[:, 1] / M
x2 = pts2[:, 0] / M
y2 = pts2[:, 1] / M
T = np.array([[1 / M, 0, 0], [0, 1 / M, 0], [0, 0, 1]])
A = []
for i in range(len(x1)):
A.append([
x1[i] * x2[i], x1[i] * y2[i], x1[i], y1[i] * x2[i], y1[i] * y2[i],
y1[i], x2[i], y2[i], 1
])
u, s, v_h = np.linalg.svd(A)
f = v_h[-1, :]
F = f.reshape((3, 3))
F = helper.refineF(F, pts1 / M, pts2 / M)
F = helper._singularize(F)
F_unnorm = np.transpose(T) @ (F @ T)
return F_unnorm
def eightpoint(pts1, pts2, M):
# Replace pass by your implementation
# normalize points
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]
F = V[-1,:].reshape(3,3)
F = helper.refineF(F, pts1, pts2)
F = helper._singularize(F)
# un normalize data
T = np.diag([1.0/M, 1.0/M, 1.0])
F = np.dot(np.transpose(T), np.dot(F,T))
# save results
np.savez('../results/q2_1.npz', F=F, M=M)
return F