python代码学习

图像归一化处理：

在代码中看到图像的2种处理方式：

• img/255.0
• image =image/ 255
• img/127.5 - 1

• image = (image-127.5 )/ 127.5 

第一种是对图像进行归一化，范围为[0, 1]，第二种也是对图像进行归一化，范围为[-1, 1]，这两种只是归一化范围不同。

上、下采样：

scipy.ndimage.interpolation.zoom函数

scipy.ndimage.interpolation.zoom-CSDN博客

scipy.ndimage.interpolation.zoom(input, zoom, output=None, order=3, mode='constant', cval=0.0, prefilter=True)[source]

Zoom an array.

input：输入数组

zoom：类型为float或sequence，沿轴的缩放系数。 如果float，每个轴的缩放是相同的。 如果sequence，zoom应包含每个轴的一个值。

output：放置输出的数组，或返回数组的dtype

order：样条插值的顺序，默认为3.顺序必须在0-5范围内。

?获取文件夹下的所有文件名：

os.listdir（）:

python中os.listdir用法_os.listdir()函数用法-CSDN博客

glob.glob() + os.path.join() ：找到文件路径，拼接路径_glob.glob(os.path.join-CSDN博客

创建卷积层：

tf.nn.conv2d()函数

tf.nn.conv2d()函数详解(strides与padding的关系)-CSDN博客

?ORB算法：（特征匹配，图像对齐）

无人机航拍图像匹配——ORB算法实践（含代码）_orb实现-CSDN博客

这个blog讲解的非常清晰非常好。

寻找图像中的关键点，创建相应的二进制特征向量，并在ORB描述符中将它们组合在一起。

#角点检测，角点数500
orb = cv2.ORB_create(500)
#描述子生成
keypoints1, descriptors1 = orb.detectAndCompute(image1, None)
keypoints2, descriptors2 = orb.detectAndCompute(image2, None)
# 暴力匹配
matcher = cv2.DescriptorMatcher_create(cv2.DESCRIPTOR_MATCHER_BRUTEFORCE_HAMMING)
# 特征点匹配
matches = matcher.match(descriptors1, descriptors2)

#滤波去除不好的特征点

ratio_threshold = 0.4
#ratio_threshold一般设置在0.4-0.8之间，如果对精度要求极高，可尽量小。当然，如果设置的太小，可能导致筛选后的匹配点数目稀少，如果少于4对，将会报错。
good_matches = []

for match in matches:
    if hasattr(match, 'distance'):
        m = match.distance
#m代表匹配点之间的差异，当然越小越好，通过这个步骤可以剔除离群点。
        if hasattr(match, 'trainIdx'):
            n = matches[match.trainIdx].distance
            if m < ratio_threshold * n:
                good_matches.append(match)
        else:
            good_matches.append(match)

#计算转移矩阵
# 提取匹配的特征点的坐标
src_points = np.float32([keypoints1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
dst_points = np.float32([keypoints2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)

# 计算单应矩阵
H, _ = cv2.findHomography(src_points, dst_points, cv2.RANSAC, 3)
#H ,_= cv2.findHomography(src_points, dst_points)
# 输出单应矩阵H
print("Homography Matrix:")
print(H)

# 计算每对匹配点的误差L2
errors = []
right_point=[]
thrshold=10
for match in good_matches:
    kp1 = keypoints1[match.queryIdx]
    kp2 = keypoints2[match.trainIdx]
    pt1 = np.array([kp1.pt[0], kp1.pt[1], 1])
    pt2 = np.array([kp2.pt[0], kp2.pt[1], 1])
    pt1_transformed = np.dot(H, pt1)
    error = np.linalg.norm(pt1_transformed - pt2) ** 2
    if np.linalg.norm(pt1_transformed - pt2)<thrshold :
        right_point.append(np.linalg.norm(pt1_transformed - pt2))
    errors.append(error)

# 计算误差的和L1
L1 = sum(errors)

# 计算均方误差MSE
MSE = np.sqrt(L1) / len(errors)
num_right=len(right_point)
num_all=len(errors)
precision=num_right/num_all

print("MSE:", MSE)
print("总匹配点数:",num_all )
print("正确匹配点数:",num_right )
print("precision:", precision)

#匹配结果展示
result = cv2.drawMatches(image1, keypoints1, image2, keypoints2, good_matches, None,
                         matchColor=(0, 255, 0), singlePointColor=(0, 0, 255), flags=cv2.DrawMatchesFlags_DEFAULT)
# result = cv2.drawMatches(color_image1, keypoints1, color_image2, keypoints2, good_matches, None,
#                          matchColor=(0, 255, 0), singlePointColor=(0, 0, 255), flags=cv2.DrawMatchesFlags_DEFAULT)

# 调整线条宽度
line_thickness = 2
for match in good_matches:
    pt1 = (int(keypoints1[match.queryIdx].pt[0]), int(keypoints1[match.queryIdx].pt[1]))
    pt2 = (int(keypoints2[match.trainIdx].pt[0]), int(keypoints2[match.trainIdx].pt[1]))
    cv2.line(result, pt1, pt2, (0, 0, 255), thickness=line_thickness)

# 创建匹配结果显示窗口
cv2.namedWindow('Matches', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Matches', 800, 600)
# 显示匹配结果
cv2.imshow('Matches', result)
cv2.waitKey(0)
cv2.destroyAllWindows()

定位关键点ORB_create()函数解析_cv2.orb_create()-CSDN博客

单应性矩阵计算：

不同视角的两张图进行特征匹配，通过四对特征进行图像之间的变换。

 # Find homography 单应性矩阵计算
    h, mask = cv2.findHomography(points1, points2, cv2.RANSAC)

[计算机视觉] 一篇文章教你学会单应性矩阵Homography（Python/C++）_单应性矩阵如何计算-CSDN博客