#特征匹配实战：SIFT/ORB算法、图像拼接、关键点检测完整指南

"""
特征匹配标准流程：

1. 特征检测：在图像中找到关键点
2. 特征描述：为每个关键点生成描述符
3. 特征匹配：在不同图像间匹配相似的特征
4. 几何验证：使用RANSAC等方法去除错误匹配
5. 应用：根据匹配结果执行具体任务
"""

import cv2
import numpy as np

def feature_matching_pipeline(img1_path, img2_path):
    """
    特征匹配标准流程演示
    """
    # 1. 加载图像
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    
    # 2. 特征检测器
    detector = cv2.SIFT_create()
    
    # 3. 检测关键点和描述符
    kp1, desc1 = detector.detectAndCompute(img1, None)
    kp2, desc2 = detector.detectAndCompute(img2, None)
    
    # 4. 特征匹配器
    matcher = cv2.BFMatcher()
    matches = matcher.knnMatch(desc1, desc2, k=2)
    
    # 5. Lowe's Ratio Test过滤
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    # 6. 返回匹配结果
    return {
        'img1': img1,
        'img2': img2,
        'kp1': kp1,
        'kp2': kp2,
        'desc1': desc1,
        'desc2': desc2,
        'matches': good_matches
    }

def sift_algorithm_explained():
    """
    SIFT算法详细步骤
    """
    """
    SIFT算法四大步骤：
    
    1. 尺度空间极值检测
       - 构建高斯金字塔
       - 计算DoG（Difference of Gaussians）
       - 检测极值点作为候选关键点
    
    2. 关键点定位
       - 精确定位关键点位置
       - 去除低对比度的点
       - 去除边缘响应
    
    3. 方向分配
       - 计算关键点的主方向
       - 实现旋转不变性
    
    4. 关键点描述
       - 生成128维描述符
       - 对光照变化鲁棒
    """
    
def sift_feature_detection(image_path):
    """
    SIFT特征检测详细实现
    """
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 创建SIFT检测器
    # 参数说明：
    # nfeatures: 最大特征点数
    # nOctaveLayers: 每个八度的层数
    # contrastThreshold: 对比度阈值
    # edgeThreshold: 边缘阈值
    # sigma: 高斯核标准差
    sift = cv2.SIFT_create(
        nfeatures=500,
        contrastThreshold=0.04,
        edgeThreshold=10,
        sigma=1.6
    )
    
    # 检测关键点和描述符
    keypoints, descriptors = sift.detectAndCompute(gray, None)
    
    # 绘制关键点
    img_with_keypoints = cv2.drawKeypoints(
        img, keypoints, None, 
        flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
    )
    
    return {
        'original': img,
        'keypoints': keypoints,
        'descriptors': descriptors,
        'keypoints_visualized': img_with_keypoints,
        'keypoint_count': len(keypoints)
    }

def sift_parameter_optimization():
    """
    SIFT参数优化指南
    """
    """
    SIFT参数调整策略：
    
    1. nfeatures:
       - 默认0（无限制）→ 根据需要调整
       - 大场景：1000-2000
       - 小场景：200-500
    
    2. contrastThreshold:
       - 默认0.04 → 降低检测更多点，提高减少噪声
       - 低纹理：0.02-0.03
       - 高纹理：0.05-0.08
    
    3. edgeThreshold:
       - 默认10 → 控制边缘响应
       - 默认值通常合适
    
    4. sigma:
       - 默认1.6 → 高斯核标准差
       - 与DoG构造相关，通常不变
    """

def sift_feature_matching(img1_path, img2_path):
    """
    SIFT特征匹配实现
    """
    # 加载图像
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
    # SIFT特征检测
    sift = cv2.SIFT_create(nfeatures=1000)
    kp1, desc1 = sift.detectAndCompute(gray1, None)
    kp2, desc2 = sift.detectAndCompute(gray2, None)
    
    # 特征匹配
    # 使用FLANN匹配器（更快）
    FLANN_INDEX_KDTREE = 1
    index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
    search_params = dict(checks=50)
    flann = cv2.FlannBasedMatcher(index_params, search_params)
    
    matches = flann.knnMatch(desc1, desc2, k=2)
    
    # Lowe's Ratio Test
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    # 绘制匹配结果
    img_matches = cv2.drawMatches(
        img1, kp1, img2, kp2, good_matches, None,
        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS
    )
    
    return {
        'img1': img1,
        'img2': img2,
        'matches': good_matches,
        'match_visualization': img_matches,
        'match_count': len(good_matches)
    }

def match_quality_evaluation(matches, good_matches):
    """
    匹配质量评估
    """
    if len(matches) > 0:
        match_ratio = len(good_matches) / len(matches)
        return {
            'total_matches': len(matches),
            'good_matches': len(good_matches),
            'match_ratio': match_ratio,
            'quality': 'Good' if match_ratio > 0.1 else 'Poor'
        }
    else:
        return {'quality': 'No matches found'}

def orb_algorithm_explained():
    """
    ORB算法组成
    """
    """
    ORB = FAST关键点检测器 + BRIEF描述符 + 方向补偿
    
    1. FAST关键点检测
       - 快速角点检测算法
       - 计算效率高
    
    2. BRIEF描述符
       - 二进制描述符
       - 存储和匹配速度快
    
    3. 方向补偿
       - 计算关键点主方向
       - 实现旋转不变性
    """

def orb_feature_detection(image_path):
    """
    ORB特征检测实现
    """
    img = cv2.imread(image_path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 创建ORB检测器
    # 参数说明：
    # nfeatures: 最大特征点数
    # scaleFactor: 金字塔缩放因子
    # nlevels: 金字塔层数
    # edgeThreshold: 边缘阈值
    # patchSize: 描述符patch大小
    orb = cv2.ORB_create(
        nfeatures=1000,
        scaleFactor=1.2,
        nlevels=8,
        edgeThreshold=31,
        patchSize=31
    )
    
    # 检测关键点和描述符
    keypoints, descriptors = orb.detectAndCompute(gray, None)
    
    # 绘制关键点
    img_with_keypoints = cv2.drawKeypoints(
        img, keypoints, None,
        flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS
    )
    
    return {
        'original': img,
        'keypoints': keypoints,
        'descriptors': descriptors,
        'keypoints_visualized': img_with_keypoints,
        'keypoint_count': len(keypoints)
    }

def orb_parameter_optimization():
    """
    ORB参数优化指南
    """
    """
    ORB参数调整策略：
    
    1. nfeatures:
       - 默认500 → 根据需求调整
       - 实时应用：200-500
       - 精确匹配：1000-2000
    
    2. scaleFactor:
       - 默认1.2 → 控制金字塔缩放
       - 快速：1.3-1.4
       - 精确：1.1-1.2
    
    3. nlevels:
       - 默认8 → 金字塔层数
       - 大尺度变化：10-12
       - 小尺度变化：6-8
    
    4. WTA_K:
       - 默认2 → BRIEF描述符维度
       - WTA_K=3或4可提高区分性
    """

def orb_feature_matching(img1_path, img2_path):
    """
    ORB特征匹配实现
    """
    # 加载图像
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
    # ORB特征检测
    orb = cv2.ORB_create(nfeatures=1000)
    kp1, desc1 = orb.detectAndCompute(gray1, None)
    kp2, desc2 = orb.detectAndCompute(gray2, None)
    
    # ORB使用汉明距离，适合二进制描述符
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    matches = bf.match(desc1, desc2)
    
    # 根据距离排序
    matches = sorted(matches, key=lambda x: x.distance)
    
    # 选择最佳匹配
    good_matches = matches[:50]  # 选择前50个最佳匹配
    
    # 绘制匹配结果
    img_matches = cv2.drawMatches(
        img1, kp1, img2, kp2, good_matches, None,
        flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS
    )
    
    return {
        'img1': img1,
        'img2': img2,
        'matches': good_matches,
        'match_visualization': img_matches,
        'match_count': len(good_matches)
    }

def hamming_distance_matching(desc1, desc2, threshold=60):
    """
    汉明距离匹配（ORB专用）
    """
    # 使用Hamming距离匹配二进制描述符
    matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
    matches = matcher.knnMatch(desc1, desc2, k=2)
    
    # 应用距离阈值过滤
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < threshold and m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    return good_matches

def brute_force_matcher_comparison():
    """
    暴力匹配器不同距离度量比较
    """
    """
    BFMatcher支持的距离度量：
    
    1. NORM_L2: 欧几里得距离（SIFT/SURF）
    2. NORM_L1: 曼哈顿距离
    3. NORM_HAMMING: 汉明距离（ORB/BRIEF）
    4. NORM_HAMMING2: 增强汉明距离
    """
    
def bf_matcher_strategies(img1_path, img2_path):
    """
    BFMatcher不同策略实现
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
    # SIFT特征（使用L2距离）
    sift = cv2.SIFT_create()
    kp1_sift, desc1_sift = sift.detectAndCompute(gray1, None)
    kp2_sift, desc2_sift = sift.detectAndCompute(gray2, None)
    
    # 不同匹配策略
    # 策略1：Cross-check（一对一）
    bf_cross = cv2.BFMatcher(cv2.NORM_L2, crossCheck=True)
    matches_cross = bf_cross.match(desc1_sift, desc2_sift)
    
    # 策略2：knn匹配
    bf_knn = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
    matches_knn = bf_knn.knnMatch(desc1_sift, desc2_sift, k=2)
    
    # 策略3：Radius匹配
    bf_radius = cv2.BFMatcher(cv2.NORM_L2, crossCheck=False)
    matches_radius = bf_radius.radiusMatch(desc1_sift, desc2_sift, maxDistance=100)
    
    return {
        'cross_check_matches': matches_cross,
        'knn_matches': matches_knn,
        'radius_matches': matches_radius
    }

def flann_matcher_explained():
    """
    FLANN匹配器详解
    """
    """
    FLANN (Fast Library for Approximate Nearest Neighbors)
    - 适用于大数据集
    - 比暴力匹配快得多
    - 适合高维特征（如SIFT）
    """

def flann_matcher_strategies(img1_path, img2_path):
    """
    FLANN匹配器不同策略
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
    # SIFT特征
    sift = cv2.SIFT_create()
    kp1, desc1 = sift.detectAndCompute(gray1, None)
    kp2, desc2 = sift.detectAndCompute(gray2, None)
    
    # 策略1：KDTree（适用于低维特征）
    FLANN_INDEX_KDTREE = 0
    index_params_kdtree = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
    search_params = dict(checks=50)
    flann_kdtree = cv2.FlannBasedMatcher(index_params_kdtree, search_params)
    matches_kdtree = flann_kdtree.knnMatch(desc1, desc2, k=2)
    
    # 策略2：LSH（适用于二进制特征）
    FLANN_INDEX_LSH = 6
    index_params_lsh = dict(
        algorithm=FLANN_INDEX_LSH,
        table_number=6,
        key_size=12,
        multi_probe_level=1
    )
    flann_lsh = cv2.FlannBasedMatcher(index_params_lsh, search_params)
    
    return {
        'kdtree_matches': matches_kdtree,
        'flann_lsh': flann_lsh
    }

def ransac_algorithm_explained():
    """
    RANSAC算法原理
    """
    """
    RANSAC (Random Sample Consensus)
    用于从包含异常值的数据集中估计数学模型参数
    
    RANSAC步骤：
    1. 随机选择最小样本集
    2. 拟合模型
    3. 计算内点数量
    4. 重复直到找到最佳模型
    5. 用所有内点重新拟合模型
    """
    
def ransac_geometric_verification(img1_path, img2_path):
    """
    RANSAC几何验证实现
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
    
    # 特征检测和匹配
    orb = cv2.ORB_create(nfeatures=1000)
    kp1, desc1 = orb.detectAndCompute(gray1, None)
    kp2, desc2 = orb.detectAndCompute(gray2, None)
    
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
    matches = bf.knnMatch(desc1, desc2, k=2)
    
    # Lowe's ratio test
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    if len(good_matches) >= 4:
        # 提取匹配点
        src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        
        # 使用RANSAC计算单应矩阵
        H, mask = cv2.findHomography(
            src_pts, dst_pts,
            cv2.RANSAC,
            ransacReprojThreshold=5.0,  # 重投影误差阈值
            maxIters=2000,              # 最大迭代次数
            confidence=0.999            # 置信度
        )
        
        # 计算内点数量
        inliers = np.sum(mask) if mask is not None else 0
        outliers = len(good_matches) - inliers
        
        return {
            'matches': good_matches,
            'homography_matrix': H,
            'mask': mask,
            'inliers': inliers,
            'outliers': outliers,
            'inlier_ratio': inliers / len(good_matches) if len(good_matches) > 0 else 0
        }
    else:
        return {'error': 'Not enough matches for RANSAC'}

class ImageStitcher:
    """
    图像拼接器
    """
    
    def __init__(self, detector_type='SIFT', matcher_type='BF'):
        self.detector_type = detector_type
        self.matcher_type = matcher_type
        
        # 初始化检测器
        if detector_type == 'SIFT':
            self.detector = cv2.SIFT_create(nfeatures=1000)
        elif detector_type == 'ORB':
            self.detector = cv2.ORB_create(nfeatures=1000)
        else:
            raise ValueError("Unsupported detector type")
    
    def detect_features(self, image):
        """检测图像特征"""
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        keypoints, descriptors = self.detector.detectAndCompute(gray, None)
        return keypoints, descriptors
    
    def match_features(self, desc1, desc2):
        """匹配特征"""
        if self.detector_type == 'SIFT':
            # SIFT使用FLANN
            FLANN_INDEX_KDTREE = 1
            index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
            search_params = dict(checks=50)
            matcher = cv2.FlannBasedMatcher(index_params, search_params)
            matches = matcher.knnMatch(desc1, desc2, k=2)
            
            # Lowe's ratio test
            good_matches = []
            for match_pair in matches:
                if len(match_pair) == 2:
                    m, n = match_pair
                    if m.distance < 0.75 * n.distance:
                        good_matches.append(m)
        else:  # ORB
            matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
            matches = matcher.knnMatch(desc1, desc2, k=2)
            
            # Lowe's ratio test
            good_matches = []
            for match_pair in matches:
                if len(match_pair) == 2:
                    m, n = match_pair
                    if m.distance < 0.75 * n.distance:
                        good_matches.append(m)
        
        return good_matches
    
    def estimate_homography(self, kp1, kp2, matches):
        """估计单应矩阵"""
        if len(matches) >= 4:
            src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
            dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
            
            H, mask = cv2.findHomography(
                src_pts, dst_pts, cv2.RANSAC, 5.0
            )
            return H, mask
        else:
            return None, None
    
    def stitch_images(self, img1, img2):
        """拼接两张图像"""
        # 检测特征
        kp1, desc1 = self.detect_features(img1)
        kp2, desc2 = self.detect_features(img2)
        
        # 匹配特征
        matches = self.match_features(desc1, desc2)
        
        if len(matches) >= 4:
            # 估计单应矩阵
            H, mask = self.estimate_homography(kp1, kp2, matches)
            
            if H is not None:
                # 计算拼接图像的尺寸
                h1, w1 = img1.shape[:2]
                h2, w2 = img2.shape[:2]
                
                # 计算变换后的四个角点
                corners1 = np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)
                corners2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)
                transformed_corners = cv2.perspectiveTransform(corners2, H)
                
                # 合并角点
                all_corners = np.concatenate((corners1, transformed_corners), axis=0)
                
                # 计算画布尺寸
                [x_min, y_min] = np.int32(all_corners.min(axis=0).ravel())
                [x_max, y_max] = np.int32(all_corners.max(axis=0).ravel())
                
                # 计算平移矩阵
                translation = np.array([[1, 0, -x_min], [0, 1, -y_min], [0, 0, 1]])
                
                # 应用变换并拼接
                result = cv2.warpPerspective(img2, translation @ H, (x_max - x_min, y_max - y_min))
                
                # 将第一张图像放在合适位置
                result[-y_min:h1-y_min, -x_min:w1-x_min] = img1
                
                return {
                    'panorama': result,
                    'matches': matches,
                    'homography': H,
                    'status': 'Success'
                }
            else:
                return {'status': 'Failed to compute homography'}
        else:
            return {'status': 'Not enough matches for stitching'}

def basic_image_stitching(img1_path, img2_path):
    """
    基础图像拼接示例
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    
    stitcher = ImageStitcher(detector_type='SIFT')
    result = stitcher.stitch_images(img1, img2)
    
    return result

def advanced_image_stitching(img1_path, img2_path):
    """
    高级图像拼接技术
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    
    # 多尺度特征检测
    def multiscale_feature_detection(image, scales=[1.0, 0.7, 0.5]):
        all_kp = []
        all_desc = []
        
        for scale in scales:
            scaled_img = cv2.resize(image, None, fx=scale, fy=scale)
            gray = cv2.cvtColor(scaled_img, cv2.COLOR_BGR2GRAY)
            
            sift = cv2.SIFT_create(nfeatures=500)
            kp, desc = sift.detectAndCompute(gray, None)
            
            # 调整关键点坐标到原始图像尺寸
            for point in kp:
                point.pt = (point.pt[0] / scale, point.pt[1] / scale)
                point.octave = int(np.log2(1/scale))  # 调整八度信息
            
            all_kp.extend(kp)
            if desc is not None:
                if all_desc == []:
                    all_desc = desc
                else:
                    all_desc = np.vstack((all_desc, desc))
        
        return all_kp, all_desc
    
    # 检测多尺度特征
    kp1, desc1 = multiscale_feature_detection(img1)
    kp2, desc2 = multiscale_feature_detection(img2)
    
    # 使用FLANN匹配
    FLANN_INDEX_KDTREE = 1
    index_params = dict(algorithm=FLANN_INDEX_KDTREE, trees=5)
    search_params = dict(checks=50)
    flann = cv2.FlannBasedMatcher(index_params, search_params)
    matches = flann.knnMatch(desc1, desc2, k=2)
    
    # Lowe's ratio test
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    # RANSAC验证
    if len(good_matches) >= 4:
        src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        
        H, mask = cv2.findHomography(
            src_pts, dst_pts, cv2.RANSAC, 5.0, maxIters=2000
        )
        
        # 图像融合（使用线性渐变）
        h1, w1 = img1.shape[:2]
        h2, w2 = img2.shape[:2]
        
        # 计算变换后的图像边界
        corners1 = np.float32([[0, 0], [0, h1], [w1, h1], [w1, 0]]).reshape(-1, 1, 2)
        corners2 = np.float32([[0, 0], [0, h2], [w2, h2], [w2, 0]]).reshape(-1, 1, 2)
        transformed_corners = cv2.perspectiveTransform(corners2, H)
        
        all_corners = np.concatenate((corners1, transformed_corners), axis=0)
        [x_min, y_min] = np.int32(all_corners.min(axis=0).ravel())
        [x_max, y_max] = np.int32(all_corners.max(axis=0).ravel())
        
        translation = np.array([[1, 0, -x_min], [0, 1, -y_min], [0, 0, 1]])
        
        # 变换第二张图像
        warped_img2 = cv2.warpPerspective(
            img2, translation @ H, (x_max - x_min, y_max - y_min)
        )
        
        # 创建第一张图像的画布
        canvas = np.zeros((y_max - y_min, x_max - x_min, 3), dtype=img1.dtype)
        canvas[-y_min:h1-y_min, -x_min:w1-x_min] = img1
        
        # 简单的图像融合（可以改进为多频带融合）
        result = np.where(canvas == 0, warped_img2, 
                         np.where(warped_img2 == 0, canvas, 
                                 (canvas.astype(float) + warped_img2.astype(float)) / 2)).astype(np.uint8)
        
        return {
            'panorama': result,
            'matches_count': len(good_matches),
            'inliers': np.sum(mask) if mask is not None else 0,
            'homography': H
        }
    else:
        return {'status': 'Not enough matches for advanced stitching'}

def panoramic_stitching_pipeline(image_paths):
    """
    全景图像拼接流水线（多张图像）
    """
    if len(image_paths) < 2:
        return {'status': 'Need at least 2 images for stitching'}
    
    # 从第一张图像开始逐步拼接
    result = cv2.imread(image_paths[0])
    
    for i in range(1, len(image_paths)):
        next_img = cv2.imread(image_paths[i])
        
        stitcher = ImageStitcher(detector_type='SIFT')
        stitch_result = stitcher.stitch_images(result, next_img)
        
        if stitch_result['status'] == 'Success':
            result = stitch_result['panorama']
        else:
            print(f"Failed to stitch image {i}: {stitch_result['status']}")
            break
    
    return result

def object_recognition_with_features(template_path, scene_path):
    """
    基于特征匹配的目标识别
    """
    template = cv2.imread(template_path)
    scene = cv2.imread(scene_path)
    
    # 特征检测
    sift = cv2.SIFT_create(nfeatures=1000)
    
    kp_template, desc_template = sift.detectAndCompute(
        cv2.cvtColor(template, cv2.COLOR_BGR2GRAY), None
    )
    kp_scene, desc_scene = sift.detectAndCompute(
        cv2.cvtColor(scene, cv2.COLOR_BGR2GRAY), None
    )
    
    # 特征匹配
    bf = cv2.BFMatcher()
    matches = bf.knnMatch(desc_template, desc_scene, k=2)
    
    # Lowe's ratio test
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    # 几何验证
    if len(good_matches) >= 10:  # 至少需要10个匹配点
        src_pts = np.float32([kp_template[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        dst_pts = np.float32([kp_scene[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        
        H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
        
        if H is not None:
            # 获取模板图像的四个角点
            h, w = template.shape[:2]
            corners = np.float32([[0, 0], [0, h-1], [w-1, h-1], [w-1, 0]]).reshape(-1, 1, 2)
            transformed_corners = cv2.perspectiveTransform(corners, H)
            
            # 在场景图像上绘制检测到的对象边界
            scene_with_box = scene.copy()
            cv2.polylines(
                scene_with_box, 
                [np.int32(transformed_corners)], 
                True, 
                (0, 255, 0), 
                3, 
                cv2.LINE_AA
            )
            
            return {
                'object_detected': True,
                'scene_with_box': scene_with_box,
                'match_count': len(good_matches),
                'homography': H
            }
    
    return {'object_detected': False, 'match_count': len(good_matches)}

def feature_based_image_alignment(img1_path, img2_path):
    """
    基于特征的图像对齐
    """
    img1 = cv2.imread(img1_path)
    img2 = cv2.imread(img2_path)
    
    # 特征检测和匹配
    orb = cv2.ORB_create(nfeatures=1000)
    kp1, desc1 = orb.detectAndCompute(cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY), None)
    kp2, desc2 = orb.detectAndCompute(cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY), None)
    
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
    matches = bf.knnMatch(desc1, desc2, k=2)
    
    good_matches = []
    for match_pair in matches:
        if len(match_pair) == 2:
            m, n = match_pair
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
    if len(good_matches) >= 4:
        src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)
        
        H, mask = cv2.findHomography(dst_pts, src_pts, cv2.RANSAC, 5.0)
        
        if H is not None:
            # 对齐图像
            aligned_img2 = cv2.warpPerspective(img2, H, (img1.shape[1], img1.shape[0]))
            
            return {
                'aligned_image': aligned_img2,
                'homography': H,
                'match_count': len(good_matches)
            }
    
    return {'status': 'Alignment failed'}

def feature_matching_performance_comparison():
    """
    特征匹配性能比较
    """
    """
    SIFT vs ORB 性能对比：
    
    SIFT:
    + 高精度、高稳定性
    + 尺度和旋转不变性好
    - 计算复杂度高
    - 有专利限制
    
    ORB:
    + 计算速度快
    + 无专利限制
    + 适合实时应用
    - 精度略低于SIFT
    - 对光照变化敏感
    
    选择建议：
    - 精度要求高：SIFT/SURF
    - 实时性要求高：ORB/BRISK
    - 平衡考虑：AKAZE
    """