def negation3(self):
"""
error in curent params
error: (-215) type == CV_32F || type == CV_64F in function cv::invert
:return:
"""
cv2.invert(self.cvImage.image, self.cvImage.image)
def interp_step(dog, octv, intvl, r, c): dD = deriv_3D(dog, octv, intvl, r, c) H = hessian_3D(dog, octv, intvl, r, c) H_inv = np.zeros(H.T.shape) cv2.invert(H, H_inv, cv2.DECOMP_SVD) gm = cv2.gemm(H_inv, dD, -1, None, 0) return gm
def refine_sky(bopt, image):
sky_mask = make_mask(bopt, image)
ground = np.ma.array(image,mask=cv2.cvtColor(cv2.bitwise_not(sky_mask), cv2.COLOR_GRAY2BGR)).compressed()
sky = np.ma.array(image,mask=cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR)).compressed()
ground.shape = (ground.size//3, 3)
sky.shape = (sky.size//3, 3)
ret, label, center = cv2.kmeans(np.float32(sky),2,None,(cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0),10,cv2.KMEANS_RANDOM_CENTERS)
sigma_s1, mu_s1 = cv2.calcCovarMatrix(sky[label.ravel() == 0],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
ic_s1 = cv2.invert(sigma_s1, cv2.DECOMP_SVD)[1]
sigma_s2, mu_s2 = cv2.calcCovarMatrix(sky[label.ravel() == 1],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
ic_s2 = cv2.invert(sigma_s2, cv2.DECOMP_SVD)[1]
sigma_g, mu_g = cv2.calcCovarMatrix(ground,None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
icg = cv2.invert(sigma_g, cv2.DECOMP_SVD)[1]
if cv2.Mahalanobis(mu_s1, mu_g, ic_s1) > cv2.Mahalanobis(mu_s2, mu_g, ic_s2):
mu_s = mu_s1
sigma_s = sigma_s1
ics = ic_s1
else:
mu_s = mu_s2
sigma_s = sigma_s2
ics = ic_s2
for x in range(image.shape[1]):
cnt = np.sum(np.less(spatial.distance.cdist(image[0:bopt[x], x],mu_s,'mahalanobis',VI=ics),spatial.distance.cdist(image[0:bopt[x], x],mu_g,'mahalanobis',VI=icg)))
if cnt < (bopt[x] / 2):bopt[x] = 0
return bopt
def getRSByNewtonsMethod(leftUpperPoint, leftDownPoint, rightUpperPoint,
rightDownPoint, x, y, noIteration):
baseRS = np.zeros((1, 2), dtype="float64")
baseRS[0, 0] = 0.5
baseRS[0, 1] = 0.5
basePoint = np.zeros((1, 2), np.float64)
basePoint[0, 0] = x
basePoint[0, 1] = y
for x in range(0, noIteration):
titeratedP = np.zeros((1, 2), np.float64)
titeratedP[0, 0] = (1 - baseRS[0, 1]) * (
(1 - baseRS[0, 0]) * leftDownPoint[0] +
baseRS[0, 0] * rightDownPoint[0]) + baseRS[0, 1] * (
baseRS[0, 0] * rightUpperPoint[0] +
(1 - baseRS[0, 0]) * leftUpperPoint[0])
titeratedP[0, 1] = (1 - baseRS[0, 1]) * (
(1 - baseRS[0, 0]) * leftDownPoint[1] +
baseRS[0, 0] * rightDownPoint[1]) + baseRS[0, 1] * (
baseRS[0, 0] * rightUpperPoint[1] +
(1 - baseRS[0, 0]) * leftUpperPoint[1])
jacobian = createJacobian(baseRS[0, 0], baseRS[0, 1], leftDownPoint,
rightDownPoint, rightUpperPoint,
leftUpperPoint)
invertedJacobian = np.zeros((2, 2), dtype="float64")
cv2.invert(jacobian, invertedJacobian, cv2.DECOMP_LU)
baseRS = baseRS - invertedJacobian * (titeratedP - basePoint)
return baseRS
def __original_points_coords(point_list):
"""
Detects the coordinates of the board on the original image.
:param point_list: List of the relative points in the sequence of
image transformations done in each layer.
:return: The coordinates in the original image of the chessboard
corners and the coordinates of each of the corners of the
chessboard squares as a pair of board_corners and
square_corners.
"""
ptslims = np.float32([[0, 0], [1200, 0], [1200, 1200], [0, 1200]])
last_index = len(point_list) - 1
# Compute all of the transformation matrixes
transf_mats = []
for i in range(last_index):
transf_mat = cv2.getPerspectiveTransform(np.float32(point_list[i]),
ptslims)
cv2.invert(transf_mat, transf_mat)
transf_mats.append(transf_mat)
# Multiply into an equivalent single transformation matrix
transf_mat = transf_mats[0]
for i in range(1, last_index):
transf_mat = transf_mat.dot(transf_mats[i])
# Transform the actual corner points
transf_points = cv2.perspectiveTransform(
np.float32(point_list[last_index]).reshape(-1, 1, 2), transf_mat)
board_corners = np.int32(
[transf_points[i][0] for i in range(len(transf_points))])
# Now obtain the corners of each square in the chessboard
# To do so we need also the last transformation matrix
last_transf_mat = cv2.getPerspectiveTransform(
np.float32(point_list[last_index]), ptslims)
cv2.invert(last_transf_mat, last_transf_mat)
transf_mat = transf_mat.dot(last_transf_mat)
# Generate the corners of the squares as if the board were of size
# 1200x1200
corners = []
for row_corner in range(0, 1200 + 150, 150):
for col_corner in range(0, 1200 + 150, 150):
corners.append([row_corner, col_corner])
# Transform the corners of the squares
square_corners = cv2.perspectiveTransform(
np.float32(corners).reshape(-1, 1, 2), transf_mat)
square_corners = np.int32(
[square_corners[i][0] for i in range(len(square_corners))])
return board_corners, square_corners
def TSAI(Hmaker2world, Hgrid2cam):
A = []
n = len(Hgrid2cam)
Hgij = np.zeros(Hmaker2world.shape)
Hcij = np.zeros(Hgrid2cam.shape)
for i in range(n - 1):
Hgij[:, :,
i] = cv2.invert(Hmaker2world[:, :, i + 1]) * Hmaker2world[:, :, i]
Hcij[:, :, i] = Hgrid2cam[:, :, i + 1] * cv2.invert(Hgrid2cam[:, :, i])
rgij = cv2.Rodrigues()
def hartleyRectify(points1, points2, imgSize, M1, M2, D1, D2, F = None):
F, mask = cv2.findFundamentalMat(points1, points2, cv2.FM_RANSAC, 3, 0.99)
#print 'mask\n', mask
retval, H1, H2 = cv2.stereoRectifyUncalibrated(
points1, points2, F, imgSize)
retval, M1i = cv2.invert(M1); retval, M2i = cv2.invert(M2)
R1, R2 = np.dot(np.dot(M1i, H1), M1), np.dot(np.dot(M2i, H2), M2)
map1x, map1y = cv2.initUndistortRectifyMap(M1, D1, R1, M1, imgSize, cv2.CV_32FC1)
map2x, map2y = cv2.initUndistortRectifyMap(M2, D2, R2, M2, imgSize, cv2.CV_32FC1)
return (map1x, map1y, map2x, map2y), F
def hartleyRectify(points1, points2, imgSize, M1, M2, D1, D2, F):
# F, mask = cv2.findFundamentalMat(points1, points2, cv2.FM_RANSAC, 3, 0.99)
# print 'mask\n', mask
retval, H1, H2 = cv2.stereoRectifyUncalibrated(
points1, points2, F, imgSize)
retval, M1i = cv2.invert(M1);
retval, M2i = cv2.invert(M2)
R1, R2 = np.dot(np.dot(M1i, H1), M1), np.dot(np.dot(M2i, H2), M2)
map1x, map1y = cv2.initUndistortRectifyMap(M1, D1, R1, M1, imgSize, cv2.CV_32FC1)
map2x, map2y = cv2.initUndistortRectifyMap(M2, D2, R2, M2, imgSize, cv2.CV_32FC1)
return (map1x, map1y, map2x, map2y), F
def inv(a):
if not isinstance(a, cp.Mat):
raise TypeError("Must use Mat objects for inv()")
elif not cp.CV_[a.dtype.name] in [cv.CV_32F, cv.CV_64F]:
raise TypeError("Must use float32 or float64 dtype for inv()")
shape = (a.shape[1], a.shape[0])
out = cp.Mat(shape, dtype=a.dtype, UMat=a.UMat)
if shape[0] == shape[1]:
decompType = cv.DECOMP_LU
else:
decompType = cv.DECOMP_SVD
cv.invert(a._, dst=out._, flags=decompType)
return out
def desenhalinha(self, frame, H):
start_line = (self.point_in_model[0][0][0].astype(int),
self._model.params['upperLineY'])
end_line = (self.point_in_model[0][0][0].astype(int),
self._model.params['lowerLineY'])
md = self.model_image
print("startl: %s" % (start_line, ))
print("endll: %s" % (end_line, ))
cv2.line(md, start_line, end_line, (255, 0, 0), 2)
cv2.imshow('linha_modelo', md)
ldst = self._modelTr.dst
cv2.line(ldst, start_line, end_line, (255, 0, 0), 2)
cv2.imshow('modelo tudo', ldst)
res, inv_H = cv2.invert(H)
model_line_points = np.array([start_line, end_line], dtype=np.float32)
field_line_points = cv2.perspectiveTransform(
np.array([model_line_points]), inv_H)
start_line_field = (field_line_points[0][0][0],
field_line_points[0][0][1])
end_line_field = (field_line_points[0][1][0],
field_line_points[0][1][1])
print("startl_field: %s" % (start_line_field, ))
print("endll_field: %s" % (end_line_field, ))
#frm=frame
#cv2.line(frm, start_line_field, end_line_field, (0, 0, 255), 2)
#cv2.imshow('linha_field', frm)
#cv2.waitKey()
height, width, depth = frame.shape
line_mask = np.zeros((height, width), np.uint8)
line_image = np.zeros((height, width, 3), np.uint8)
cv2.line(line_image, start_line_field, end_line_field, (0, 0, 255), 4)
cv2.line(line_mask, start_line_field, end_line_field, (255, 255, 255),
3)
# field_mask = self.mask_builder(image, 38, 88, 34, 101, 0, 174)
hsv_image = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
field_mask = cv2.inRange(hsv_image, self._hsv_low, self._hsv_high)
field_mask_inv = cv2.bitwise_not(field_mask)
cv2.imshow('field_mask', field_mask)
cv2.imshow('field_mask_inv', field_mask_inv)
#cv2.waitKey()
lineToDraw = cv2.addWeighted(line_mask, 1, field_mask_inv, -1, 0)
lineToDraw_inv = cv2.bitwise_not(lineToDraw)
line = cv2.bitwise_and(line_image, line_image, mask=lineToDraw)
field = cv2.bitwise_and(frame, frame, mask=lineToDraw_inv)
output = cv2.addWeighted(line, 1, field, 1, 0)
#cv2.imshow('line', line)
#cv2.imshow('field', field)
#cv2.imshow('output', output)
#cv2.waitKey()
return output
def calculateMatchingPrecisionAndRecallAirsim(**kwargs):
width, height = kwargs.get('width'), kwargs.get('height')
H1to2 = kwargs.get('H1to2')
depth1 = kwargs.get('depth1')
depth2 = kwargs.get('depth2')
keypoints1 = kwargs.get('points1')
keypoints2 = kwargs.get('points2')
matches1 = kwargs.get('matches1')
matches2 = kwargs.get('matches2')
nTruePositiveCount: int = 0
err_thresh: float = kwargs.get('err_thresh')
fPrecision:float = 0.0
fRecall:float = 0.0
assert (matches1.size() == matches2.size())
nMatches:int = len(matches1)
K = numpy.eye(3).astype(numpy.float32)
pK = K.reshape(9)
pK[4] = pK[0] = width/2
pK[2] = width/2
pK[5] = height/2
_, Kinv = cv2.invert(K)
matches1t = calcProjectionsAirsim(keypoints1, H1to2, depth1, K, Kinv);
calcProjectionsAirsim(matches1, H1to2, depth1, K, Kinv, matches1t);
def warp_back(warped, m, Lane):
warp_zero = np.zeros_like(warped).astype(np.uint8)
color_warp = np.dstack((warp_zero, warp_zero, warp_zero))
# Recast the x and y points into usable format for cv2.fillPoly()
pts_left = np.array(
[np.transpose(np.vstack([Lane.left_line.allx, Lane.left_line.ally]))])
pts_right = np.array([
np.flipud(
np.transpose(
np.vstack([Lane.right_line.allx, Lane.right_line.ally])))
])
pts = np.hstack((pts_left, pts_right))
Lane.left_line.pointx = pts_left[0, :, 0]
Lane.right_line.pointx = pts_right[0, :, 0]
Lane.left_line.pointy = pts_left[0, :, 1]
Lane.right_line.pointy = pts_right[0, :, 1]
Lane.center = (pts_right[0][-1][0] +
pts_left[0][-1][0]) // 2 - warped.shape[1] // 2
# Draw the lane onto the warped blank image
cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))
invertible, m_inv = cv2.invert(m)
# Warp the blank back to original image space using inverse perspective matrix (Minv)
newwarp = cv2.warpPerspective(color_warp, m_inv,
(color_warp.shape[1], color_warp.shape[0]))
return newwarp, Lane
def drawCueBall(img, target, matrix):
inv = cv2.invert(matrix)
matrixInverted = np.asarray(inv[1][:, :])
# get White
lower = np.array([220, 220, 220])
upper = np.array([255, 255, 255])
shapeMask = cv2.inRange(img, lower, upper)
# find the contours in the mask
(cnts, _) = cv2.findContours(shapeMask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# loop over the contours
for c in cnts:
# draw the contour and show only when larger than 15
# cv2.drawContours(img, [c], -1, (0, 255, 0), 2)
(x, y), radius = cv2.minEnclosingCircle(c)
center = np.array([int(x), int(y), 1])
radius = int(radius)
if 22 < radius < 25:
translatedCenter = matrixInverted.dot(center)
cv2.circle(target,
(int(translatedCenter[0]), int(translatedCenter[1])),
16, (0, 0, 255), 2)
def readCalibrationParams(self, path):
parser = JSONParser()
jsonObj = parser.parse(path)
self.calibrationMatrix = np.array(jsonObj['cameraMatrix'],np.float32)
ret, self.inverseCalibrationMatrix = cv2.invert(self.calibrationMatrix)
self.distortCoefs = np.array(jsonObj['distortedCoefficients'], np.float32)
def transformPoints(x, y, reverse=False, integer=True):
if not reverse:
H = transform_matrix
else:
val, H = cv2.invert(transform_matrix)
# get the elements in the transform matrix
h0 = H[0, 0]
h1 = H[0, 1]
h2 = H[0, 2]
h3 = H[1, 0]
h4 = H[1, 1]
h5 = H[1, 2]
h6 = H[2, 0]
h7 = H[2, 1]
h8 = H[2, 2]
tx = (h0 * x + h1 * y + h2)
ty = (h3 * x + h4 * x + h5)
tz = (h6 * x + h7 * y + h8)
if integer:
px = int(tx / tz)
py = int(ty / tz)
Z = int(1 / tz)
else:
px = tx / tz
py = ty / tz
Z = 1 / tz
return px, py
def virtual_point(homographyMatrix):
pts = np.float32([[round(CAM_WIDTH / 2),
round(CAM_HEIGHT / 2)]]).reshape(-1, 1, 2)
m = cv2.invert(homographyMatrix)
# find the location of this same point in the projector image
dst = cv2.perspectiveTransform(pts, m[1])
return dst
def matchProfiles(model, profiles):
tProfiles = np.zeros(profiles.shape[0])
for l in range(profiles.shape[0]):
covar = model[0][l]
mean = model[1][l]
icovar = cv2.invert(covar, flags=cv2.DECOMP_SVD)[1]
m = (profiles.shape[1] - 1) / 2
n = (model[1].shape[1] - 1) / 2
dist = np.zeros(2 * (m - n) + 1)
for t in range(2 * (m - n) + 1):
tMean = translateMean(mean, t, m)
tIcovar = translateCovar(icovar, t, m)
dist[t] = cv2.Mahalanobis(profiles[l], tMean, tIcovar)
tProfiles[l] = m - n - np.argmin(dist)
''' PROFILE VISUALISATION
ppl.vlines(np.arange(mean.shape[0]), np.zeros_like(mean), mean)
ppl.show()
ppl.vlines(np.arange(profiles[20].shape[0]), np.zeros_like(profiles[20]), profiles[20])
ppl.show()
print tProfiles
'''
return tProfiles
def backproject_sample_rect(warp_matrix, sample_dims):
warp_matrix_inv = cv2.invert(warp_matrix)[1]
#warp_matrix_inv = np.array(warp_matrix_inv)/cv.Get2D(warp_matrix_inv, 2, 2)[0]
#print warp_matrix_inv
warp_matrix_inv = cv.fromarray(warp_matrix_inv)
rectified_shape = np.array((1., 1.))
width_center = rectified_shape[1] / 2
sample_dims = [x / 2 for x in sample_dims]
#roi_bottom = (rectified_shape[0] - neighborhood_length) * np.random.random() + \
# neighborhood_length
roi_bottom = 0.5
rectified_sample_roi = [
width_center - sample_dims[0], roi_bottom + sample_dims[1],
width_center - sample_dims[0], roi_bottom - sample_dims[1],
width_center + sample_dims[0], roi_bottom - sample_dims[1],
width_center + sample_dims[0], roi_bottom + sample_dims[1]
]
rectified_sample_roi = np.array(rectified_sample_roi, dtype=np.float32)
rectified_sample_roi = rectified_sample_roi.reshape((1, 4, 2))
backprojected_sample_boundary = cv.CreateMat(1, 4, cv.CV_32FC2)
rectified_sample_roi = cv.fromarray(rectified_sample_roi)
cv.PerspectiveTransform(rectified_sample_roi,
backprojected_sample_boundary, warp_matrix_inv)
return cvutils.array2point_list(np.array(backprojected_sample_boundary))
def applyHomographyToPoint(self, frame, H):
start_line = (self.point_in_model[0][0][0].astype(int),
self._model.params['upperLineY'])
end_line = (self.point_in_model[0][0][0].astype(int),
self._model.params['lowerLineY'])
start_line_scrimmage = (
self.scrimmage_point_in_model[0][0][0].astype(int),
self._model.params['upperLineY'])
end_line_scrimmage = (
self.scrimmage_point_in_model[0][0][0].astype(int),
self._model.params['lowerLineY'])
res, inv_H = cv2.invert(H)
model_line_points = np.array([start_line, end_line], dtype=np.float32)
model_line_scrimmage_points = np.array(
[start_line_scrimmage, end_line_scrimmage], dtype=np.float32)
field_line_points = cv2.perspectiveTransform(
np.array([model_line_points]), inv_H)
field_scrimmage_line_points = cv2.perspectiveTransform(
np.array([model_line_scrimmage_points]), inv_H)
start_line_field = (field_line_points[0][0][0],
field_line_points[0][0][1])
end_line_field = (field_line_points[0][1][0],
field_line_points[0][1][1])
start_scrimmage_line_field = (field_scrimmage_line_points[0][0][0],
field_scrimmage_line_points[0][0][1])
end_scrimmage_line_field = (field_scrimmage_line_points[0][1][0],
field_scrimmage_line_points[0][1][1])
return self.draw_line(frame, start_line_field, end_line_field,
start_scrimmage_line_field,
end_scrimmage_line_field)
def true_sky(border, src_image):
#制作天空图像掩码和地面图像掩码
sky_mask = make_sky_mask(src_image, border, 1)
ground_mask = make_sky_mask(src_image, border, 0)
#扣取天空图像和地面图像
sky_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR))
ground_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(ground_mask, cv2.COLOR_GRAY2BGR))
#将天空和地面区域shape转换为n*3
sky_image = sky_image_ma.compressed()
ground_image = ground_image_ma.compressed()
sky_image.shape = (sky_image.size//3, 3)
ground_image.shape = (ground_image.size//3, 3)
# k均值聚类调整天空区域边界--2类
sky_image_float = np.float32(sky_image)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
flags = cv2.KMEANS_RANDOM_CENTERS
compactness, labels, centers = cv2.kmeans(sky_image_float, 2, None, criteria, 10, flags)
sky_label_0 = sky_image[labels.ravel() == 0]
sky_label_1 = sky_image[labels.ravel() == 1]
sky_covar_0, sky_mean_0 = cv2.calcCovarMatrix(sky_label_0, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
sky_covar_1, sky_mean_1 = cv2.calcCovarMatrix(sky_label_1, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
ground_covar, ground_mean = cv2.calcCovarMatrix(ground_image, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
ic_s0 = cv2.invert(sky_covar_0, cv2.DECOMP_SVD)[1]
ic_s1 = cv2.invert(sky_covar_1, cv2.DECOMP_SVD)[1]
ic_g = cv2.invert(ground_covar, cv2.DECOMP_SVD)[1]
#推断真实的天空区域
if cv2.Mahalanobis(sky_mean_0, ground_mean, ic_s0) > cv2.Mahalanobis(sky_mean_1, ground_mean, ic_s1):
sky_mean = sky_mean_0
sky_covar = sky_covar_0
ic_s = ic_s0
else:
sky_mean = sky_mean_1
sky_covar = sky_covar_1
ic_s = ic_s1
return sky_covar,sky_mean,ic_s,ground_covar, ground_mean,ic_g
def __init__(self, homography_matrix):
Transformation.__init__(self)
self._homography = homography_matrix
self._homography_inverse = None
_, inv = cv2.invert(self._homography)
self._homography_inverse = inv
def multi_thread_load_dataset(files):
sizes = []
labels = []
Ks = []
for f in files:
img_path = os.path.join(root, 'training', 'image_2',
'{}.png'.format(f))
label_path = os.path.join(root, 'training', 'label_2',
'{}.txt'.format(f))
calib_path = os.path.join(root, 'training', 'calib',
'{}.txt'.format(f))
# process shape
img = cv2.imread(img_path)
sizes.append(np.array([img.shape[1], img.shape[0]]))
# process calib
P2 = calib_utils.get_calib_P2(calib_path).reshape((3, -1))
K = P2[:3, :3]
T = P2[:3, 3]
invK = cv2.invert(K, flags=cv2.DECOMP_LU)[1]
TT = np.matmul(invK, T.reshape(-1, 1)).reshape((-1))
with open(label_path) as f:
objs = []
for line in f.read().splitlines():
splits = line.split()
cls = utils.name_2_label(splits[0])
if cls == -1:
continue
cls = np.array([float(cls)])
bbox = np.array([
float(splits[4]),
float(splits[5]),
float(splits[6]),
float(splits[7])
])
dim = np.array(
[float(splits[8]),
float(splits[9]),
float(splits[10])]) # H, W, L
loc = np.array([
float(splits[11]),
float(splits[12]) - float(splits[8]) / 2,
float(splits[13])
]) + TT # x, y, z
alpha = np.array([float(splits[3])])
ry = np.array([float(splits[-1])])
objs.append(
np.concatenate([cls, bbox, dim, alpha, ry, loc],
axis=0).reshape((1, -1)))
labels.append(np.concatenate(objs, axis=0))
Ks.append(K.reshape((-1)))
return sizes, labels, Ks
def remove_noise_and_smooth(img):
# img = cv2.imread(file_name, 0)
# img = cv2.adaptiveThreshold(img.astype(np.uint8), 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 9, 41)
kernel = np.ones((1, 1), np.uint8)
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel)
or_image = cv2.bitwise_or(img, closing)
or_image = cv2.invert(or_image)
kernel = np.ones((1, 1), np.uint8)
or_image = cv2.erode(or_image, kernel, iterations=1)
return or_image
def get2Dmapping(self, srcPts, dstPts):
"""
Use findHomography to get a transform from the 2D source points to the corresponding 2D dest points.
Will return a src2dst tranformation matrix, as well as the inverted dst2src matrix
"""
src2dst_transform, mask = cv2.findHomography(srcPts.reshape(-1, 1, 2),
dstPts.reshape(-1, 1, 2),
cv2.RANSAC, 5.0)
dst2src_transform = cv2.invert(
src2dst_transform
) # note: the transformation matrix is in index=1 of the returned var
return src2dst_transform, dst2src_transform[1]
def overlaySolutionSkewed(originalCorners, originalImage, newImage, M):
rows, cols, __ = np.shape(originalImage)
_, M = cv2.invert(M)
unwarped = cv2.warpPerspective(
newImage,
M,
(cols, rows),
)
cv2.fillPoly(originalImage, pts=[originalCorners], color=(0, 0, 0))
final2 = cv2.add(unwarped, originalImage)
return final2
def warp_blob(self, blob, transform_matrix):
if transform_matrix.dtype != numpy.float32:
new_transform = numpy.ndarray(transform_matrix.shape,
numpy.float32)
new_transform[:] = transform_matrix
transform_matrix = new_transform
_, invert_transform = cv2.invert(transform_matrix)
shape = (blob.shape[0], 3)
extended_blob = numpy.ndarray(shape, dtype=blob.dtype)
extended_blob[...,:2] = blob
extended_blob[...,2] = 1.
warped_blob = invert_transform.dot(extended_blob.transpose())
return warped_blob.transpose()[...,:2]
def fixedCvInvert(self, H):
"""[If the determinate is zero, OpenCV returns a wrong inverted matrix. ]
Args:
H ([type]): [3x3 Matrix]
Returns:
[type]: [Inverted matrix]
"""
if (cv2.determinant(H) != 0.0):
return cv2.invert(H)[1]
else:
return np.array([[1., 0., -H[0, -1]], [0., 1., -H[1, -1]],
[0., 0., 0.]])
def _correct_colors(self, parents, next_H, order):
log.debug('Recoloring in order %s',
','.join(self._images[i].name for i in order))
labs = [
cv2.cvtColor(i.image, cv2.COLOR_RGB2LAB).astype(np.float32)
for i in self._images
]
for dst_idx in order:
assert dst_idx != self.center
src_idx = parents[dst_idx]
src = self._images[src_idx]
dst = self._images[dst_idx]
log.debug('Color Correcting %s => %s', src.name, dst.name)
src, dst = src.image, dst.image
src_mask = np.zeros(src.shape[:2], dtype=np.uint8)
dst_mask = np.zeros(dst.shape[:2], dtype=np.uint8)
H = next_H[dst_idx]
src_corners = cv2.perspectiveTransform(
image_corners(dst).reshape(1, 4, 2), H)
dst_corners = cv2.perspectiveTransform(
image_corners(src).reshape(1, 4, 2),
cv2.invert(H)[1])
log.debug('Using relative H:\n%s', H)
log.debug('Src mask corners:\n%s', src_corners)
log.debug('Dst mask corners:\n%s', dst_corners)
cv2.fillPoly(src_mask, np.rint(src_corners).astype(int), 255)
cv2.fillPoly(dst_mask, np.rint(dst_corners).astype(int), 255)
if self.debug:
imshow(src_mask)
imshow(cv2.bitwise_and(src, src, mask=src_mask))
imshow(dst_mask)
imshow(cv2.bitwise_and(dst, dst, mask=dst_mask))
src_lab = labs[src_idx]
dst_lab = labs[dst_idx]
# Probably a better way to do this
# Adapted from http://www.pyimagesearch.com/2014/06/30/super-fast-color-transfer-images/
src_mean, src_std = color_stats(src_lab, mask=src_mask)
dst_mean, dst_std = color_stats(dst_lab, mask=dst_mask)
dst_lab[:] = ((dst_lab - dst_mean) *
(dst_std / src_std)) + src_mean
for image, lab in zip(self._images, labs):
lab = np.clip(lab, 0, 255).astype(np.uint8)
image.image[:] = cv2.merge(
cv2.split(cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)) +
[image.image[..., 3]])
def dst_xy_to_src_xy(xy, normH, src_size=(1, 1), dsize=(1, 1)):
'''
xy: x, y coords or point in src image
normH: normalized homography matrix
src_size: size of src image (width, height)
dsize: size of dest space (weight, height)
'''
normH = cv2.invert(normH)[1]
x = float(xy[0]) / src_size[0]
y = float(xy[1]) / src_size[1]
dst_x = (normH[0, 0] * x + normH[0, 1] * y +
normH[0, 2]) / (normH[2, 0] * x + normH[2, 1] * y + normH[2, 2])
dst_y = (normH[1, 0] * x + normH[1, 1] * y +
normH[1, 2]) / (normH[2, 0] * x + normH[2, 1] * y + normH[2, 2])
return (dst_x * dsize[0], dst_y * dsize[1])
def warp_perspective(img_list, ymax, ymin, xmax, xmin, ht, homography):
stitch_r = np.zeros((ymax - ymin, xmax - xmin, 3)).astype(np.uint8)
trans_mat = cv2.invert(ht.dot(homography))[1]
for i in range(ymax - ymin):
for j in range(xmax - xmin):
img_i = int(
(trans_mat[1][0] * j + trans_mat[1][1] * i + trans_mat[1][2]) /
(trans_mat[2][0] * j + trans_mat[2][1] * i + trans_mat[2][2]))
img_j = int(
(trans_mat[0][0] * j + trans_mat[0][1] * i + trans_mat[0][2]) /
(trans_mat[2][0] * j + trans_mat[2][1] * i + trans_mat[2][2]))
if img_i >= 0 and img_j >= 0 and img_i < img_list[1].shape[
0] and img_j < img_list[1].shape[1]:
stitch_r[i][j] = img_list[1][img_i][img_j]
return stitch_r
def detect(self, imageGray, M):
_, M_inv = cv2.invert(M)
im_dst = self.correctPerspective(imageGray, M_inv)
im_Color = cv2.cvtColor(im_dst, cv2.COLOR_GRAY2BGR)
#self.inProcess = True
#im_O = lineDetect(im_dst)
x1 = 20
y1 = int(im_dst.shape[0] * 0.15)
x2 = im_dst.shape[1] - 20
y2 = y1 + 55
cv2.rectangle(im_Color, (x1, y1), (x2, y2), (0, 0, 255), 1)
L, im_Color = self.detectLetters(im_dst, (x1, y1), (x2, y2))
return L, im_Color
elif opt in ("-v", "--verbose"):
_debug = 1
elif opt in ("-b", "--database"):
database = arg
if not os.path.isfile(database):
print >> sys.stderr, "Database %s does not exist." % database
sys.exit(1)
conn = sqlite3.connect(database)
setUpDatabase(database)
c = conn.cursor()
if _debug == 1:
print "reading out data..."
namelist = getNames(c)
channellist = getChannels(c)
(eigval, eigbase, avg) = getEigenBase(c)
(_, inveigbase) = cv2.invert(eigbase)
inveigbase = numpy.matrix(inveigbase)
processed = 0
matrix = []
LIMIT = len(namelist)
length = min(LIMIT,len(namelist))
start = time.time()
last = start
#TODO: aptimisation: use arrays instead of dict()s
representants = dict()
for name in namelist[:LIMIT]:
representants[name[0]] = dict()
for channel in channellist:
representants[name[0]][channel[0]] = getRepresentants(name[0],channel[0],inveigbase,c)
for name in range(0,len(namelist[:LIMIT])-1):
processed += 1
#
flags = cv2.COVAR_NORMAL | cv2.COVAR_ROWS
grouped_data = []
icovariance = []
for c in range(0, 10):
grouped_data.append([])
for i in range(0, len(digits)):
if labels[i] == c:
grouped_data[c].append(digits[i])
print 'group:', c, len(grouped_data[c])
x = np.array(grouped_data[c])
covar, mean = cv2.calcCovarMatrix(x, flags)
icovar = np.empty(covar.shape, covar.dtype)
cv2.invert(covar, icovar, cv2.DECOMP_SVD)
icovariance.append(icovar)
#
# Q5: For each group, calculate the Mahalanobis distance of every element
# to the centroid, then draw the centroid followed by the three farthest
# elements (showing their Mahalanobis distance).
#
for index, centroid in enumerate(centroids):
points = np.float32(grouped_data[index])
icovar = np.float32(icovariance[index])
mdistance = []
for point in points:
def distance_finder(frame, lines = None, fallas = None):
if lines != None:
# Variables importantes
distaciaFocal = 1286 #1286.07
largoEntreLineas = 25 #cm
altura_camara = 11.2 #cm
# Variables menos importantes
height = frame.shape[0]
width = frame.shape[1]
#Desempacamos
[lineaIzq,lineaDer] = lines
### Ahora viene el calculo de lineas paralelas ###
# Primero calculamos los cuatro puntos limites de las lineas electricas.
rectOriginal = np.float32(perspective_bound(frame, [lineaIzq,lineaDer]))
# Ahora definimos los limites de la nueva imagen
rectPerspective = np.float32([[0,0], [height,0], [0,height], [height,height]])
# Calculamos la matriz de perspectiva
if lineaIzq == None:
frame_perspective = np.zeros((height,height,3))
else:
M = cv2.getPerspectiveTransform(rectOriginal,rectPerspective)
# Transformamos la imagen para ver como queda
frame_perspective = cv2.warpPerspective(frame,M, (height,height))
# #Iteramos sobre todos los puntos que encontramos para encontrar su paralela
for color in fallas:
for centro in fallas[color]:
#Transformamos el centroide del
centro_perspectiva = cv2.perspectiveTransform(np.array([[centro[0]]],dtype = 'float32'),M) #Los puntos que le entran a la funcion perspectiveTransform, tienen que ser de la forma [[[x1,y1],[x2,y2, ...]]], con ESA cantidad de parentesis.
# Calculamos el mismo punto en la otra linea
centro_perspectiva = centro_perspectiva[0][0].copy()
if centro_perspectiva[0] < height/2:
punto_contrario_perspectiva = np.array([height, centro_perspectiva[1]])
else:
punto_contrario_perspectiva = np.array([0, centro_perspectiva[1]], dtype = 'float')
# Destransformamos el punto
# print "M = {}".format(M)
# print "invM = {}".format(cv2.invert(M))
punto_contrario = cv2.perspectiveTransform(np.array([[punto_contrario_perspectiva]],dtype = 'float32'),cv2.invert(M)[1])
# Graficamos, las lineas que encontramos
punto_contrario = punto_contrario[0][0].copy()
cv2.line(frame,tuple(centro[0]),tuple(punto_contrario),coloresDibujo['azul'],2)
# Calculamos la distancia en pixeles
distPixeles = np.sqrt(np.square(centro[0][0] - punto_contrario[0]) + np.square(centro[0][1] - punto_contrario[1]))
# Usamos la ecuacion de similitud triangular para sacar la distancia
distCamara = largoEntreLineas*distaciaFocal/distPixeles
# Ahora usamos la relacion de pitagoras para calcular la distancia de la falla al chasis
distChasis = np.sqrt(np.square(distCamara) - np.square(altura_camara))
# guardamos la distancia en centimetros en el diccionario de fallas
centro[1] = distChasis
return fallas
# #Iteramos sobre todos los puntos que encontramos para encontrar su paralela
for color in fallas:
for centro in fallas[color]:
#Transformamos el centroide del
centro_perspectiva = cv2.perspectiveTransform(np.array([[centro[0]]],dtype = 'float32'),M) #Los puntos que le entran a la funcion perspectiveTransform, tienen que ser de la forma [[[x1,y1],[x2,y2, ...]]], con ESA cantidad de parentesis.
# Calculamos el mismo punto en la otra linea
centro_perspectiva = centro_perspectiva[0][0].copy()
if centro_perspectiva[0] < height/2:
punto_contrario_perspectiva = np.array([height, centro_perspectiva[1]])
else:
punto_contrario_perspectiva = np.array([0, centro_perspectiva[1]], dtype = 'float')
# Destransformamos el punto
# print "M = {}".format(M)
# print "invM = {}".format(cv2.invert(M))
punto_contrario = cv2.perspectiveTransform(np.array([[punto_contrario_perspectiva]],dtype = 'float32'),cv2.invert(M)[1])
# Graficamos, las lineas que encontramos
punto_contrario = punto_contrario[0][0].copy()
cv2.line(frame_copy,tuple(centro[0]),tuple(punto_contrario),coloresDibujo['azul'],2)
# Calculamos la distancia en pixeles
distPixeles = np.sqrt(np.square(centro[0][0] - punto_contrario[0]) + np.square(centro[0][1] - punto_contrario[1]))
# Usamos la ecuacion de similitud triangular para sacar la distancia
distCamara = largoEntreLineas*distaciaFocal/distPixeles
# Ahora usamos la relacion de pitagoras para calcular la distancia de la falla al chasis
distChasis = np.sqrt(np.square(distCamara) - np.square(altura_camara))
# guardamos la distancia en centimetros en el diccionario de fallas
centro[1] = distChasis
# Ahora imprimimos y mostramos todo.
# Pequeno for para graficar las fallas y sus distancias.
def inverted(img, s):
img = img.astype(float)
im = cv2.invert(img)
write(im, 'inverted/inv_'+s+'.jpg' )
def distanceFinder(self, frame, lines = None, fallas = None):
if lines != None:
#Desempacamos
[lineaIzq,lineaDer] = lines
### Ahora viene el calculo de lineas paralelas ###
# Primero calculamos los cuatro puntos limites de las lineas electricas.
rectOriginal = np.float32(self.perspective_bound(frame, [lineaIzq,lineaDer]))
# Ahora definimos los limites de la nueva imagen
rectPerspective = np.float32([[0,0], [self.height,0], [0,self.height], [self.height,self.height]])
# Calculamos la matriz de perspectiva
if lineaIzq == None:
frame_perspective = np.zeros((self.height,self.height,3))
else:
M = cv2.getPerspectiveTransform(rectOriginal,rectPerspective)
if 'distance' in self.debug_mode:
# Transformamos la imagen para ver como queda
frame_perspective = cv2.warpPerspective(frame,M, (self.height,self.height))
print(" [-] Calcular matrix de perspectiva: {}".format(time.time() - self.last_time))
self.last_time = time.time()
# #Iteramos sobre todos los puntos que encontramos para encontrar su paralela
for color in fallas:
for centro in fallas[color]:
#Transformamos el centroide del
centro_perspectiva = cv2.perspectiveTransform(np.array([[centro[0]]],dtype = 'float32'),M) #Los puntos que le entran a la funcion perspectiveTransform, tienen que ser de la forma [[[x1,y1],[x2,y2, ...]]], con ESA cantidad de parentesis.
# Calculamos el mismo punto en la otra linea
centro_perspectiva = centro_perspectiva[0][0].copy()
if centro_perspectiva[0] < self.height/2:
punto_contrario_perspectiva = np.array([self.height, centro_perspectiva[1]])
else:
punto_contrario_perspectiva = np.array([0, centro_perspectiva[1]], dtype = 'float')
# Destransformamos el punto
# print "M = {}".format(M)
# print "invM = {}".format(cv2.invert(M))
punto_contrario = cv2.perspectiveTransform(np.array([[punto_contrario_perspectiva]],dtype = 'float32'),cv2.invert(M)[1])
# Graficamos, las lineas que encontramos
punto_contrario = punto_contrario[0][0].copy()
cv2.line(frame,tuple(centro[0]),tuple(punto_contrario),self.coloresDibujo['azul'],2)
# Calculamos la distancia en pixeles
distPixeles = np.sqrt(np.square(centro[0][0] - punto_contrario[0]) + np.square(centro[0][1] - punto_contrario[1]))
# Usamos la ecuacion de similitud triangular para sacar la distancia
distCamara = self.largoEntreLineas*self.distaciaFocal/distPixeles
# Ahora usamos la relacion de pitagoras para calcular la distancia de la falla al chasis
distChasis = np.sqrt(np.square(distCamara) - np.square(self.altura_camara))
# guardamos la distancia en centimetros en el diccionario de fallas
centro[1] = distChasis
print(" [-] Trans y destransformaciones de perspectiva {}".format(time.time() - self.last_time))
self.last_time = time.time()
#Debugging output
if 'distance' in self.debug_mode:
# Sacamos una copia de la imagen
frame_copy = self.frame.copy()
# Dibujamos un poco de informacion de utilidad
for color in fallas:
i = 1
for objeto in fallas[color]:
cv2.circle(frame_copy,tuple(objeto[0]),40,self.coloresDibujo[color],3)
cv2.putText(frame_copy, "{} #{}".format(color,i), (objeto[0][0] + 45, objeto[0][1]), cv2.FONT_HERSHEY_SIMPLEX,1.0, self.coloresDibujo[color], 2)
cv2.putText(frame_copy, "{:0.2f}cm".format(objeto[1]), (objeto[0][0] + 45, objeto[0][1] + 20), cv2.FONT_HERSHEY_SIMPLEX,0.7, self.coloresDibujo[color], 2)
i+=1
resultado = np.hstack((frame_copy,frame_perspective))
resultado = cv2.resize(resultado,None,fx=0.5, fy=0.5, interpolation = cv2.INTER_AREA)
self.frame_debug_distance = resultado.copy()
print(" [-] Distance debug: {}".format(time.time() - self.last_time))
self.last_time = time.time()
return fallas
## Get Matches
im = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
keypoints,descriptors = detector.detectAndCompute(im,None)
captured = CapturedImage(im, descriptors,keypoints)
matches = getMatches(captured, target)
## Only update Homography and board if we can see it
if len(matches) > 4:
## Get points, find Homography
src_pts = np.float32([ target.getKeypoints()[m.queryIdx].pt for m in matches ]).reshape(-1,1,2)
dst_pts = np.float32([ captured.getKeypoints()[m.trainIdx].pt for m in matches ]).reshape(-1,1,2)
H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,6.0)
successInv, invH = cv2.invert(H)
imRect = cv2.warpPerspective(im, invH, (w,h))
matchesMask = mask.ravel().tolist()
xPieces = [None]*9
if None in pieces:
## Check for X's
for quadrant in xrange(0,9):
quadrantImage, upperLeft, lowerRight = extractQuadrant(imRect, quadrant, boardX, boardY, w, h)
# cv2.rectangle(frame,(top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]), 100, 2)
res = cv2.matchTemplate(quadrantImage,X_template,cv2.TM_CCOEFF_NORMED)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res) # this currently searches whole image. can use mask for each box
# print "maxval = ", max_locval
def invert(matrix):
return cv2.invert(matrix)[1] # only output the result, not the status; use with care
T = np.array([[1, 0, 0, 0],[0, 1, 0, 0],[0,0, 1, dist],[0, 0, 0, 1]])
A2 = np.array([[f, 0, w/2,0],[0, f, h/2, 0], [0,0,1,0]])
A2[0:3,0:3]=camera_matrix
M2 = np.dot(A2,np.dot(T, np.dot(R,A1)))
print(M2)
warped = cv2.warpPerspective(gray2, M2, (sz[1],sz[0]),flags=cv2.WARP_INVERSE_MAP)
cv2.imwrite(str(mnum)+'POST.jpg',warped)
cap.release()
_,M3 = cv2.invert(M2)
ymin = ceil(-M3[2,2]/ M3[2,1])
yyy = np.arange(ymin,1000)
out = (M3[2,1]*yyy + M3[2,2])
#plt.plot(yyy,out)
# this is how to convert x-y positions in the image to real 2-d coordinates
original = np.array([((0,800), (1920,800),(0,1000),(1920, 1000))], dtype=np.float32)
original = np.array([((0,800),(0,0))], dtype=np.float32)
converted = cv2.perspectiveTransform(original, M3)
print(converted)
plt.plot(converted[0,:,0],converted[0,:,1],'.')
def calibrate(self, confFile, output):
parser = JSONParser()
jsonObj = parser.parseCameraConf(confFile, self.id)
print 'Calibration status: parsing configuration file'
if jsonObj is None:
print 'Wrong conf file'
return None
print 'Calibration status: parsing finished'
patternSize = (jsonObj['patternWidth']-1,jsonObj['patternHeight']-1)
patternPoints = np.zeros((np.prod(patternSize), 3), np.float32)
patternPoints[:, :2] = np.indices(patternSize).T.reshape(-1, 2)
patternPoints *= jsonObj['squareSize']
w, h = self.resolution[0], self.resolution[1]
objPoints = []
imgPoints = []
frameCnt = 0
frameDelay = int((jsonObj['inputDelay']/1000.0)*60)
print 'Calibration status: selecting frames for calibration'
while(1):
ret, frame = self.capture.read()
if (ret is True) and ((frameCnt % frameDelay) == 0):
if(jsonObj['flipAroundHorizontalAxis'] is True):
cv2.flip(frame, 0, frame)
found, corners = cv2.findChessboardCorners(frame,patternSize)
if found:
term = (cv2.TERM_CRITERIA_EPS*cv2.TERM_CRITERIA_COUNT, 30, 0.1)
cvtFrame = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
cv2.cornerSubPix(cvtFrame,corners,(5,5),(-1,-1), term)
else:
continue
imgPoints.append(corners.reshape(-1,2))
objPoints.append(patternPoints)
if(len(imgPoints) == jsonObj['numOfFrames']):
break
frameCnt += 1
print 'Calibration status: frames selected'
print 'Calibration status: started calibration'
rms, cameraMatrix, distCoefs, rvecs, tvecs = cv2.calibrateCamera(objPoints, imgPoints, (int(w), int(h)), self.getFlags(jsonObj), None)
print 'Calibration status: calibration finished'
self.calibrationMatrix = cameraMatrix
ret, self.inverseCalibrationMatrix = cv2.invert(cameraMatrix)
self.distortCoefs = distCoefs
print "Calibration status: writing results to file"
object = {'id':self.id, 'cameraMatrix': cameraMatrix.tolist(), 'distortedCoefficients': distCoefs.tolist()}
jsonObj = json.dumps(object)
parser.writeJSON(jsonObj,output)
print("RMS:", rms)
def polynomial_triangulation(u1, P1, u2, P2):
"""
Polynomial (Optimal) triangulation.
Uses Linear-Eigen for final triangulation.
Relative speed: 0.1
(u1, P1) is the reference pair containing normalized image coordinates (x, y) and the corresponding camera matrix.
(u2, P2) is the second pair.
u1 and u2 are matrices: amount of points equals #rows and should be equal for u1 and u2.
The status-vector is based on the assumption that all 3D points have finite coordinates.
"""
P1_full = np.eye(4); P1_full[0:3, :] = P1[0:3, :] # convert to 4x4
P2_full = np.eye(4); P2_full[0:3, :] = P2[0:3, :] # convert to 4x4
P_canon = P2_full.dot(cv2.invert(P1_full)[1]) # find canonical P which satisfies P2 = P_canon * P1
# "F = [t]_cross * R" [HZ 9.2.4]; transpose is needed for numpy
F = np.cross(P_canon[0:3, 3], P_canon[0:3, 0:3], axisb=0).T
# Other way of calculating "F" [HZ (9.2)]
#op1 = (P2[0:3, 3:4] - P2[0:3, 0:3] .dot (cv2.invert(P1[0:3, 0:3])[1]) .dot (P1[0:3, 3:4]))
#op2 = P2[0:3, 0:4] .dot (cv2.invert(P1_full)[1][0:4, 0:3])
#F = np.cross(op1.reshape(-1), op2, axisb=0).T
# Project 2D matches to closest pair of epipolar lines
u1_new, u2_new = cv2.correctMatches(F, u1.reshape(1, len(u1), 2), u2.reshape(1, len(u1), 2))
# For a purely sideways trajectory of 2nd cam, correctMatches() returns NaN for all possible points!
if np.isnan(u1_new).all() or np.isnan(u2_new).all():
F = cv2.findFundamentalMat(u1, u2, cv2.FM_8POINT)[0] # so use a noisy version of the fund mat
u1_new, u2_new = cv2.correctMatches(F, u1.reshape(1, len(u1), 2), u2.reshape(1, len(u1), 2))
# Triangulate using the refined image points
return linear_eigen_triangulation(u1_new[0], P1, u2_new[0], P2) # TODO: replace with linear_LS: better results for points not at Inf
