特征值空间：
    λ₂
    ↑
    │     角点区域
    │    (λ₁大, λ₂大)
    │
    ├───────────── 边缘区域
    │              (λ₁大, λ₂小)
    │
    └─────────────→ λ₁
    平坦区域
    (λ₁小, λ₂小)

import cv2
import numpy as np
import matplotlib.pyplot as plt

def shi_tomasi_detailed(image_path, max_corners=100, quality_level=0.01, min_distance=10):
    """
    Shi-Tomasi角点检测详细实现

    参数详解：
    max_corners: 返回的最大角点数量（0表示无限制）
    quality_level: 角点质量水平（0-1），值越小要求越高
    min_distance: 角点之间的最小欧氏距离（像素）
    """
    # 1. 读取图像
    img = cv2.imread(image_path)
    if img is None:
        raise ValueError(f"无法读取图像: {image_path}")

    # 2. 转换为灰度
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 3. Shi-Tomasi角点检测
    # cv2.goodFeaturesToTrack() 就是Shi-Tomasi的实现
    corners = cv2.goodFeaturesToTrack(gray, max_corners, quality_level, min_distance)

    # 4. 转换为整数坐标
    corners_int = np.int0(corners) if corners is not None else []

    # 5. 绘制角点
    img_marked = img.copy()
    for corner in corners_int:
        x, y = corner.ravel()
        # 绘制不同大小的圆表示响应强度
        cv2.circle(img_marked, (x, y), 5, (0, 255, 0), -1)  # 内圆
        cv2.circle(img_marked, (x, y), 7, (255, 0, 0), 2)   # 外圆边框

    return {
        'image': img_marked,
        'corners': corners,
        'corners_int': corners_int,
        'gray': gray,
        'corner_count': len(corners_int) if corners_int is not None else 0

def shi_tomasi_manual_implementation(image, max_corners=100, quality_level=0.01, min_distance=10):
    """
    手动实现Shi-Tomasi算法，理解内部原理
    """
    # 1. 计算图像梯度
    I_x = cv2.Sobel(image, cv2.CV_32F, 1, 0, ksize=3)
    I_y = cv2.Sobel(image, cv2.CV_32F, 0, 1, ksize=3)

    # 2. 计算自相关矩阵元素
    Ixx = I_x * I_x
    Iyy = I_y * I_y
    Ixy = I_x * I_y

    # 3. 高斯平滑（窗口函数）
    window_size = 3
    kernel = cv2.getGaussianKernel(window_size, 1.5)
    kernel_2d = kernel * kernel.T

    Sxx = cv2.filter2D(Ixx, -1, kernel_2d)
    Syy = cv2.filter2D(Iyy, -1, kernel_2d)
    Sxy = cv2.filter2D(Ixy, -1, kernel_2d)

    # 4. 计算每个像素的响应值（最小特征值）
    height, width = image.shape
    R = np.zeros_like(image, dtype=np.float32)

    for y in range(height):
        for x in range(width):
            # 构建自相关矩阵
            M = np.array([
                [Sxx[y, x], Sxy[y, x]],
                [Sxy[y, x], Syy[y, x]]
            ])

            # 计算特征值
            eigenvalues = np.linalg.eigvals(M)

            # Shi-Tomasi响应：最小特征值
            R[y, x] = np.min(eigenvalues)

    # 5. 非极大值抑制
    corners = []

    # 根据quality_level设置阈值
    max_response = np.max(R)
    threshold = quality_level * max_response

    # 创建响应图副本用于非极大值抑制
    R_suppressed = R.copy()

    # 找到所有超过阈值的点
    candidate_points = np.argwhere(R > threshold)

    # 按响应值排序
    candidate_responses = R[candidate_points[:, 0], candidate_points[:, 1]]
    sorted_indices = np.argsort(-candidate_responses)  # 降序

    for idx in sorted_indices:
        if len(corners) >= max_corners:
            break

        y, x = candidate_points[idx]

        # 检查最小距离
        too_close = False
        for corner in corners:
            cy, cx = corner
            dist = np.sqrt((x - cx)**2 + (y - cy)**2)
            if dist < min_distance:
                too_close = True
                break

        if not too_close:
            corners.append([x, y])  # 注意：OpenCV使用(x, y)顺序

    return np.array(corners, dtype=np.float32).reshape(-1, 1, 2), R

def compute_shi_tomasi_response_optimized(Sxx, Syy, Sxy):
    """
    优化计算Shi-Tomasi响应值（避免特征值分解）
    """
    trace = Sxx + Syy
    diff = Sxx - Syy
    discriminant = np.sqrt(diff**2 + 4 * Sxy**2)

    # 最小特征值
    lambda_min = 0.5 * (trace - discriminant)

    # 避免数值误差导致的负数
    lambda_min = np.maximum(lambda_min, 0)

    return lambda_min

周围像素编号（半径为3的圆）：
    15  00  01
 14              02
13                  03
12        p        04
11                  05
 10              06
    09  08  07

import cv2
import numpy as np

def fast_corner_detection_simple(image, threshold=20):
    """
    简化版FAST角点检测（帮助理解原理）
    """
    if len(image.shape) == 3:
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    else:
        gray = image

    height, width = gray.shape
    corners = []

    # 周围16个像素的偏移量（半径为3的圆）
    circle_offsets = [
        (0, -3), (1, -3), (2, -2), (3, -1),
        (3, 0), (3, 1), (2, 2), (1, 3),
        (0, 3), (-1, 3), (-2, 2), (-3, 1),
        (-3, 0), (-3, -1), (-2, -2), (-1, -3)
    ]

    # 遍历图像（忽略边缘）
    for y in range(3, height - 3):
        for x in range(3, width - 3):
            center_intensity = gray[y, x]

            # 检查16个像素
            brighter_count = 0
            darker_count = 0

            for dx, dy in circle_offsets:
                neighbor_intensity = gray[y + dy, x + dx]

                if neighbor_intensity > center_intensity + threshold:
                    brighter_count += 1
                elif neighbor_intensity < center_intensity - threshold:
                    darker_count += 1

            # FAST-12检测：连续12个像素满足条件
            # 简化：只要总数≥12就认为是角点
            if brighter_count >= 12 or darker_count >= 12:
                corners.append((x, y))

    return corners

def fast_with_opencv(image, threshold=20):
    """
    使用OpenCV的FAST检测器
    """
    # 创建FAST检测器
    fast = cv2.FastFeatureDetector_create(
        threshold=threshold,           # 阈值
        nonmaxSuppression=True,        # 非极大值抑制
        type=cv2.FAST_FEATURE_DETECTOR_TYPE_9_16  # 检测类型
    )

    # 检测关键点
    keypoints = fast.detect(image, None)

    # 绘制关键点
    img_with_keypoints = cv2.drawKeypoints(
        image, 
        keypoints, 
        None, 
        color=(0, 255, 0),  # 绿色
        flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
    )

    return img_with_keypoints, keypoints

def fast_with_quick_reject(image, threshold=20):
    """带快速拒绝的FAST检测"""
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    height, width = gray.shape
    corners = []

    # 快速检查的4个像素（1, 5, 9, 13号）
    quick_offsets = [(0, -3), (3, 0), (0, 3), (-3, 0)]  # 上、右、下、左

    for y in range(3, height - 3):
        for x in range(3, width - 3):
            center_intensity = gray[y, x]

            # 快速拒绝：检查4个关键像素
            quick_count = 0
            for dx, dy in quick_offsets:
                neighbor = gray[y + dy, x + dx]
                if (neighbor > center_intensity + threshold or 
                    neighbor < center_intensity - threshold):
                    quick_count += 1

            # 如果少于3个，肯定不是角点
            if quick_count < 3:
                continue

            # 完整检查16个像素
            # ...（完整检测代码）

    return corners

def non_maximum_suppression(corners, responses, min_distance=10):
    """
    非极大值抑制
    corners: 角点坐标列表 [(x1, y1), (x2, y2), ...]
    responses: 角点响应值列表
    min_distance: 最小距离
    """
    if not corners:
        return []

    # 按响应值降序排序
    sorted_indices = np.argsort(responses)[::-1]
    suppressed_corners = []

    for idx in sorted_indices:
        x, y = corners[idx]
        keep = True

        # 检查是否与已保留的角点太近
        for cx, cy in suppressed_corners:
            dist = np.sqrt((x - cx)**2 + (y - cy)**2)
            if dist < min_distance:
                keep = False
                break

        if keep:
            suppressed_corners.append((x, y))

    return suppressed_corners

# OpenCV FAST参数
fast = cv2.FastFeatureDetector_create(
    threshold=20,  # 关键参数：亮度差阈值
    # 值越小，检测越敏感（更多角点）
    # 值越大，检测越严格（更少但更稳定的角点）

    nonmaxSuppression=True,  # 非极大值抑制
    # True: 移除邻近的弱角点
    # False: 保留所有检测到的角点

    type=cv2.FAST_FEATURE_DETECTOR_TYPE_9_16
    # TYPE_9_16: 使用16个像素，需要连续9个满足条件
    # TYPE_7_12: 使用12个像素，需要连续7个
    # TYPE_5_8: 使用8个像素，需要连续5个
)

# ORB使用FAST作为角点检测器，然后：
# 1. 添加方向计算（灰度质心法）
# 2. 添加尺度不变性（图像金字塔）
# 3. 添加描述符（旋转BRIEF）

# 所以：ORB = FAST + 方向 + 金字塔 + BRIEF

import cv2
import numpy as np

# 构建高斯金字塔
def build_gaussian_pyramid(image, levels):
    pyramid = [image]
    for i in range(1, levels):
        # 高斯模糊
        blurred = cv2.GaussianBlur(pyramid[-1], (5, 5), 0)
        # 下采样（尺寸减半）
        downsampled = cv2.pyrDown(blurred)
        pyramid.append(downsampled)
    return pyramid

# 示例
image = cv2.imread('test.jpg', 0)  # 灰度图
pyramid = build_gaussian_pyramid(image, 4)

# 显示金字塔
for i, level_img in enumerate(pyramid):
    print(f"Level {i}: {level_img.shape}")

def build_laplacian_pyramid(gaussian_pyramid):
    laplacian = []
    for i in range(len(gaussian_pyramid)-1):
        # 上采样
        expanded = cv2.pyrUp(gaussian_pyramid[i+1])
        # 调整尺寸（可能因奇数尺寸需要）
        if expanded.shape != gaussian_pyramid[i].shape:
            expanded = cv2.resize(expanded, gaussian_pyramid[i].shape[::-1])
        # 相减得到拉普拉斯层
        laplacian.append(gaussian_pyramid[i] - expanded)
    laplacian.append(gaussian_pyramid[-1])  # 最后一层直接使用
    return laplacian

# ORB金字塔构建（简化版）
def build_orb_pyramid(image, scaleFactor=1.2, nlevels=8):
    pyramid = []
    current_scale = 1.0

    for level in range(nlevels):
        if level == 0:
            pyramid.append(image)
        else:
            # 计算当前层的缩放比例
            scale = 1.0 / (scaleFactor ** level)
            new_size = (int(image.shape[1] * scale), 
                       int(image.shape[0] * scale))
            # 缩放图像
            resized = cv2.resize(image, new_size)
            pyramid.append(resized)
        current_scale /= scaleFactor

    return pyramid

def detect_features_multiscale(image, detector, scaleFactor=1.2, nlevels=8):
    all_keypoints = []

    # 构建金字塔
    pyramid = build_orb_pyramid(image, scaleFactor, nlevels)

    # 在各层检测特征
    for level, level_img in enumerate(pyramid):
        # 在当前层检测特征
        keypoints = detector.detect(level_img, None)

        # 坐标转换：将当前层坐标转换回原始图像坐标
        for kp in keypoints:
            # 计算尺度因子
            scale = scaleFactor ** level
            # 调整坐标
            kp.pt = (kp.pt[0] * scale, kp.pt[1] * scale)
            # 调整特征尺度
            kp.size = kp.size * scale if hasattr(kp, 'size') else kp.size

        all_keypoints.extend(keypoints)

    return all_keypoints

import cv2

# 1. 高斯金字塔函数
img = cv2.imread('test.jpg')

# 下采样（高斯模糊+尺寸减半）
lower = cv2.pyrDown(img)

# 上采样（尺寸加倍，但信息不会增加）
higher = cv2.pyrUp(lower)

# 2. 构建自定义金字塔
def custom_pyramid(img, scale_factor=1.2, levels=5):
    pyramid = [img]
    for i in range(1, levels):
        # 计算新尺寸
        h, w = img.shape[:2]
        new_w = int(w / (scale_factor ** i))
        new_h = int(h / (scale_factor ** i))

        # 缩放
        resized = cv2.resize(img, (new_w, new_h))
        pyramid.append(resized)

    return pyramid

ORB算法流程：
    FAST角点检测
        ↓
    计算方向（灰度质心法）
        ↓
    BRIEF描述符（旋转后）

# FAST检测逻辑（简化）
def is_fast_corner(pixel, circle_pixels, threshold=20):
    """
    pixel: 中心像素亮度
    circle_pixels: 周围16个像素的亮度
    threshold: 亮度差阈值
    """
    # 连续N个像素比中心亮或暗
    brighter_count = sum(1 for p in circle_pixels if p > pixel + threshold)
    darker_count = sum(1 for p in circle_pixels if p < pixel - threshold)

    # 连续12个像素满足条件（FAST-12）
    return brighter_count >= 12 or darker_count >= 12

# ORB对FAST的改进：
# 1. 多尺度检测（图像金字塔）
# 2. 非极大值抑制（保留最强响应）
# 3. 限制特征点数量

# OpenCV实现
fast = cv2.FastFeatureDetector_create(
    threshold=20,           # 亮度差阈值
    nonmaxSuppression=True  # 非极大值抑制
)
keypoints_fast = fast.detect(gray, None)

def compute_orientation(patch):
    """
    计算特征点的方向
    patch: 特征点周围的图像块（如31×31）
    """
    # 1. 计算矩（moments）
    m00 = np.sum(patch)  # 零阶矩（总亮度）

    # 一阶矩
    m01 = 0  # 对y的矩
    m10 = 0  # 对x的矩

    height, width = patch.shape
    for y in range(height):
        for x in range(width):
            intensity = patch[y, x]
            m10 += x * intensity  # x方向矩
            m01 += y * intensity  # y方向矩

    # 2. 计算质心
    centroid_x = m10 / m00
    centroid_y = m01 / m00

    # 3. 计算方向角（从特征点到质心）
    direction = np.arctan2(centroid_y, centroid_x)  # 弧度

    return direction

图像块：
    ↑ y
    │
    │   质心 (cx, cy)
    │     ↗
    │    /
    │   / 方向角θ
    │  /
    │ / 
    │特征点 (0, 0) 
    └─────────→ x

方向：从特征点指向质心的角度

PYTHON1# 伪代码表示
2if I(p) < I(q):  # I(p)表示p点的像素亮度
3    bit = 1
4else:
5    bit = 0
6

TEXT1描述符 = [bit1, bit2, bit3, ..., bit256]
2

def brief_descriptor_original(patch, test_pairs):
    """
    原始BRIEF描述符
    patch: 图像块（已平滑）
    test_pairs: 预定义的测试点对列表
    """
    descriptor = 0

    for i, (x1, y1, x2, y2) in enumerate(test_pairs):
        # 比较两个像素的亮度
        if patch[y1, x1] < patch[y2, x2]:
            descriptor |= (1 << i)  # 设置第i位为1

    return descriptor  # 二进制串

def rbrief_descriptor(patch, orientation, test_pairs):
    """
    旋转BRIEF描述符
    orientation: 特征点方向（弧度）
    """
    # 1. 构建旋转矩阵
    cos_theta = np.cos(orientation)
    sin_theta = np.sin(orientation)
    rotation_matrix = np.array([[cos_theta, -sin_theta],
                                [sin_theta, cos_theta]])

    descriptor = 0

    for i, (x1, y1, x2, y2) in enumerate(test_pairs):
        # 2. 旋转测试点对
        p1_rotated = np.dot(rotation_matrix, [x1, y1])
        p2_rotated = np.dot(rotation_matrix, [x2, y2])

        # 3. 双线性插值获取像素值
        intensity1 = bilinear_interpolation(patch, p1_rotated[0], p1_rotated[1])
        intensity2 = bilinear_interpolation(patch, p2_rotated[0], p2_rotated[1])

        # 4. 比较
        if intensity1 < intensity2:
            descriptor |= (1 << i)

    return descriptor

# OpenCV ORB完整参数
orb = cv2.ORB_create(
    nfeatures=500,           # 保留的最大特征点数量
    scaleFactor=1.2,         # 金字塔缩放因子
    nlevels=8,               # 金字塔层数
    edgeThreshold=31,        # 边缘阈值（不检测边缘像素）
    firstLevel=0,            # 第一层金字塔
    WTA_K=2,                 # 产生每个BRIEF描述符的测试点数
    scoreType=cv2.ORB_HARRIS_SCORE,  # 角点评分类型
    patchSize=31,            # 图像块大小,生成BRIEF描述符
    fastThreshold=20         # FAST阈值
)

# 关键参数调优指南：
# 1. nfeatures: 嵌入式设备建议100-200
# 2. nlevels: 嵌入式设备建议4-6层
# 3. patchSize: 嵌入式设备建议15-21
# 4. fastThreshold: 值越大，角点越少但更稳定

图像1：特征点A₁, A₂, A₃, ...  描述符D₁, D₂, D₃, ...
图像2：特征点B₁, B₂, B₃, ...  描述符E₁, E₂, E₃, ...

问题：对于每个Dᵢ，在{Eⱼ}中找到最相似的描述符

def euclidean_distance(desc1, desc2):
    """计算两个描述符的欧氏距离"""
    return np.sqrt(np.sum((desc1 - desc2) ** 2))

# 对于128维的SIFT描述符
# dist = √[(d₁₁-e₁₁)² + (d₁₂-e₁₂)² + ... + (d₁₂₈-e₁₂₈)²]

def hamming_distance(desc1, desc2):
    """计算两个二进制描述符的汉明距离"""
    # 方法1：使用异或和位计数
    xor_result = desc1 ^ desc2
    return np.sum(np.unpackbits(xor_result))

    # 方法2：OpenCV内置函数
    # return cv2.norm(desc1, desc2, cv2.NORM_HAMMING)

import cv2
import numpy as np

def brute_force_matching(desc1, desc2, norm_type=cv2.NORM_HAMMING):
    """暴力匹配"""
    # 创建暴力匹配器
    bf = cv2.BFMatcher(norm_type, crossCheck=True)

    # 进行匹配（crossCheck=True确保双向一致）
    matches = bf.match(desc1, desc2)

    # 按距离排序（距离越小，匹配越好）
    matches = sorted(matches, key=lambda x: x.distance)

    return matches

# 使用示例
orb = cv2.ORB_create()
kp1, des1 = orb.detectAndCompute(img1, None)
kp2, des2 = orb.detectAndCompute(img2, None)

matches = brute_force_matching(des1, des2)

def knn_matching(desc1, desc2, k=2, norm_type=cv2.NORM_HAMMING):
    """KNN匹配"""
    bf = cv2.BFMatcher(norm_type)

    # 为每个特征点找到k个最佳匹配
    knn_matches = bf.knnMatch(desc1, desc2, k=k)

    return knn_matches

# 使用示例
knn_matches = knn_matching(des1, des2, k=2)

def flann_matching(desc1, desc2):
    """FLANN匹配（适合浮点描述符如SIFT）"""
    # FLANN参数
    FLANN_INDEX_KDTREE = 1
    index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
    search_params = dict(checks=50)  # 搜索精度

    # 创建FLANN匹配器
    flann = cv2.FlannBasedMatcher(index_params, search_params)

    # 进行匹配
    matches = flann.knnMatch(desc1, desc2, k=2)

    return matches

def ratio_test(knn_matches, ratio_thresh=0.75):
    """应用比率测试过滤误匹配"""
    good_matches = []

    for matches in knn_matches:
        if len(matches) >= 2:
            # 最佳匹配和次佳匹配
            best_match, second_best_match = matches[0], matches[1]

            # 应用比率测试
            if best_match.distance < ratio_thresh * second_best_match.distance:
                good_matches.append(best_match)

    return good_matches

# 使用示例
knn_matches = knn_matching(des1, des2, k=2)
good_matches = ratio_test(knn_matches, ratio_thresh=0.75)

def cross_check_matching(desc1, desc2, norm_type=cv2.NORM_HAMMING):
    """交叉验证匹配"""
    bf = cv2.BFMatcher(norm_type)

    # 正向匹配：img1→img2
    matches_12 = bf.match(desc1, desc2)

    # 反向匹配：img2→img1  
    matches_21 = bf.match(desc2, desc1)

    # 只保留双向一致的匹配
    good_matches = []
    for m12 in matches_12:
        for m21 in matches_21:
            if m12.queryIdx == m21.trainIdx and m12.trainIdx == m21.queryIdx:
                good_matches.append(m12)
                break

    return good_matches

def distance_threshold(matches, max_distance=50):
    """基于距离阈值过滤"""
    good_matches = [m for m in matches if m.distance < max_distance]
    return good_matches

import cv2
import numpy as np
import matplotlib.pyplot as plt

def feature_matching_pipeline(img1_path, img2_path):
    """完整的特征匹配流程"""

    # 1. 读取图像
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

    # 2. 特征检测与描述符计算
    orb = cv2.ORB_create(nfeatures=500)
    kp1, des1 = orb.detectAndCompute(gray1, None)
    kp2, des2 = orb.detectAndCompute(gray2, None)

    print(f"图像1特征点: {len(kp1)}")
    print(f"图像2特征点: {len(kp2)}")

    # 3. 特征匹配（使用KNN+比率测试）
    bf = cv2.BFMatcher(cv2.NORM_HAMMING)
    knn_matches = bf.knnMatch(des1, des2, k=2)

    # 4. 应用比率测试
    good_matches = []
    for m, n in knn_matches:
        if m.distance < 0.75 * n.distance:
            good_matches.append(m)

    print(f"原始匹配数: {len(knn_matches)}")
    print(f"过滤后匹配数: {len(good_matches)}")

    # 5. 可视化匹配结果
    img_matches = cv2.drawMatches(
        img1, kp1, img2, kp2, good_matches[:50],  # 只显示前50个匹配
        None, 
        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS
    )

    # 6. 显示结果
    plt.figure(figsize=(16, 8))
    plt.imshow(cv2.cvtColor(img_matches, cv2.COLOR_BGR2RGB))
    plt.title(f"特征匹配结果 (匹配数: {len(good_matches)})")
    plt.axis('off')
    plt.show()

    return {
        'keypoints1': kp1,
        'keypoints2': kp2,
        'descriptors1': des1,
        'descriptors2': des2,
        'matches': good_matches
    }

# 使用示例
# results = feature_matching_pipeline('img1.jpg', 'img2.jpg')

def evaluate_matching_quality(matches, total_keypoints1, total_keypoints2):
    """评估匹配质量"""
    # 1. 匹配率
    match_rate1 = len(matches) / total_keypoints1 * 100
    match_rate2 = len(matches) / total_keypoints2 * 100

    # 2. 平均匹配距离
    avg_distance = np.mean([m.distance for m in matches])

    # 3. 距离标准差
    std_distance = np.std([m.distance for m in matches])

    print("=== 匹配质量评估 ===")
    print(f"匹配数量: {len(matches)}")
    print(f"匹配率 (相对于图像1): {match_rate1:.1f}%")
    print(f"匹配率 (相对于图像2): {match_rate2:.1f}%")
    print(f"平均匹配距离: {avg_distance:.2f}")
    print(f"距离标准差: {std_distance:.2f}")

    return {
        'match_count': len(matches),
        'match_rate1': match_rate1,
        'match_rate2': match_rate2,
        'avg_distance': avg_distance,
        'std_distance': std_distance
    }

def visualize_match_distribution(kp1, kp2, matches):
    """可视化匹配点的分布"""
    fig, axes = plt.subplots(1, 2, figsize=(12, 6))

    # 图像1的匹配点
    img1_points = np.array([kp1[m.queryIdx].pt for m in matches])
    axes[0].scatter(img1_points[:, 0], img1_points[:, 1], s=10, alpha=0.6)
    axes[0].set_title('图像1匹配点分布')
    axes[0].set_xlabel('X')
    axes[0].set_ylabel('Y')
    axes[0].invert_yaxis()  # 图像坐标y轴向下

    # 图像2的匹配点
    img2_points = np.array([kp2[m.trainIdx].pt for m in matches])
    axes[1].scatter(img2_points[:, 0], img2_points[:, 1], s=10, alpha=0.6, color='red')
    axes[1].set_title('图像2匹配点分布')
    axes[1].set_xlabel('X')
    axes[1].set_ylabel('Y')
    axes[1].invert_yaxis()

    plt.tight_layout()
    plt.show()

# 使用两幅相关图像（如同一场景的不同视角）
# 实现完整的特征匹配流程
# 可视化匹配结果
# 评估匹配质量

# 实验不同参数对匹配结果的影响：
# 1. ORB的nfeatures参数（100, 300, 500）
# 2. 比率测试的阈值（0.5, 0.75, 0.9）
# 3. 距离阈值（30, 50, 70）
# 记录：匹配数量、正确率、处理时间

# 测试在不同条件下的匹配性能：
# 1. 旋转变化（0°, 30°, 60°）
# 2. 尺度变化（100%, 75%, 50%）
# 3. 光照变化（亮度调整）
# 4. 添加噪声（高斯噪声）

# 1. 调整ORB参数
orb = cv2.ORB_create(
    nfeatures=1000,        # 增加特征点数量
    fastThreshold=10,      # 降低FAST阈值
    scaleFactor=1.1        # 更密的尺度采样
)

# 2. 使用更宽松的匹配阈值
good_matches = ratio_test(knn_matches, ratio_thresh=0.8)  # 从0.75提高到0.8

# 1. 使用更严格的过滤
good_matches = ratio_test(knn_matches, ratio_thresh=0.6)  # 从0.75降低到0.6

# 2. 结合多种过滤方法
matches = distance_threshold(matches, max_distance=40)
matches = cross_check_matching(desc1, desc2)

# 3. 使用RANSAC进行几何验证（后续讲解）