OpenCV 手控光标（实现过程）

已于 2025-03-16 11:41:51 修改
阅读量1.1k 收藏 20
点赞数 13
文章标签： opencv 计算机视觉 人工智能
于 2025-03-13 17:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y901548/article/details/146236975
版权 
#第一版
import cv2
import mediapipe as mp

# 初始化MediaPipe手势识别模块
mp_hands = mp.solutions.hands
hands = mp_hands.Hands(
    static_image_mode=False,  # 实时视频流模式
    max_num_hands=2,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
)
mp_drawing = mp.solutions.drawing_utils


# 手势判断函数应定义在循环外部
def is_fist(hand_landmarks):
    wrist = hand_landmarks.landmark[mp_hands.HandLandmark.WRIST]
    tips = [
        mp_hands.HandLandmark.THUMB_TIP,
        mp_hands.HandLandmark.INDEX_FINGER_TIP,
        mp_hands.HandLandmark.MIDDLE_FINGER_TIP,
        mp_hands.HandLandmark.RING_FINGER_TIP,
        mp_hands.HandLandmark.PINKY_TIP
    ]

    total_distance = 0
    for tip in tips:
        tip_point = hand_landmarks.landmark[tip]
        distance = ((tip_point.x - wrist.x) ** 2 + (tip_point.y - wrist.y) ** 2) ** 0.5
        total_distance += distance
    avg_distance = total_distance / len(tips)
    return avg_distance < 0.15  # 根据实际效果调整阈值


# 调用摄像头
cap = cv2.VideoCapture(0)

while cap.isOpened():
    success, frame = cap.read()
    if not success:
        break

    # 转换颜色空间
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = hands.process(rgb_frame)

    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # 绘制关键点
            mp_drawing.draw_landmarks(
                frame, hand_landmarks, mp_hands.HAND_CONNECTIONS
            )

            # 调用手势判断函数并显示结果
            if is_fist(hand_landmarks):
                cv2.putText(frame, "Fist", (10, 50),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            else:
                cv2.putText(frame, "open", (10, 50),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    cv2.imshow('Hand Tracking', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

#第二版
import cv2
import mediapipe as mp
import math

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
with mp_hands.Hands(
        static_image_mode=False,
        max_num_hands=2,
        min_detection_confidence=0.7,
        min_tracking_confidence=0.5
) as hands:
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            break

        # 转换颜色空间并处理
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = hands.process(rgb_frame)

        if results.multi_hand_landmarks:
            for hand_landmarks in results.multi_hand_landmarks:
                # 绘制关键点（修复括号问题）
                mp_drawing.draw_landmarks(
                    frame,
                    hand_landmarks,
                    mp_hands.HAND_CONNECTIONS,
                    mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                    mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
                )

                # ---------------------- 优化后的手指计数逻辑 ----------------------

                finger_count = 0
                h, w = frame.shape[:2]

                # 修复列表生成式括号问题
                landmark_points = [(int(lm.x * w), int(lm.y * h))
                                   for lm in hand_landmarks.landmark]

                # 拇指判断（优化角度计算）
                thumb_tip = landmark_points[mp_hands.HandLandmark.THUMB_TIP.value]
                thumb_ip = landmark_points[mp_hands.HandLandmark.THUMB_IP.value]
                thumb_mcp = landmark_points[mp_hands.HandLandmark.THUMB_MCP.value]

                # 向量点积计算角度（添加分母保护）
                vec1 = (thumb_ip[0] - thumb_mcp[0], thumb_ip[1] - thumb_mcp[1])
                vec2 = (thumb_tip[0] - thumb_ip[0], thumb_tip[1] - thumb_ip[1])
                dot_product = vec1[0] * vec2[0] + vec1[1] * vec2[1]
                denominator = (math.hypot(*vec1) * math.hypot(*vec2)) + 1e-6
                angle = math.degrees(math.acos(dot_product / denominator))

                # 其他手指判断（示例：食指）
                index_tip_y = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_TIP.value][1]
                index_pip_y = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_PIP.value][1]
                if index_tip_y < index_pip_y:  # 指尖在PIP关节上方
                    finger_count += 1
                index_tip_y1 = landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_TIP.value][1]
                index_pip_y1= landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_PIP.value][1]
                if index_tip_y1 < index_pip_y1:  # 指尖在PIP关节上方
                    finger_count += 1
                index_tip_y2= landmark_points[mp_hands.HandLandmark.RING_FINGER_TIP.value][1]
                index_pip_y2 = landmark_points[mp_hands.HandLandmark.RING_FINGER_PIP.value][1]
                if index_tip_y2 < index_pip_y2:  # 指尖在PIP关节上方
                    finger_count += 1

                # 显示计数结果
                cv2.putText(frame, f"Fingers: {finger_count}", (10, 30),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)

        cv2.imshow('Hand Tracking', frame)
        cv2.imshow('Hand Tracking', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
        if cv2.waitKey(5) & 0xFF == 27:
            break

cap.release()
cv2.destroyAllWindows()
#第三版
import cv2
import mediapipe as mp
import math

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
with mp_hands.Hands(
        static_image_mode=False,
        max_num_hands=2,
        min_detection_confidence=0.7,
        min_tracking_confidence=0.5
) as hands:
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            break

        # 转换颜色空间并处理
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = hands.process(rgb_frame)

        if results.multi_hand_landmarks:
            for hand_landmarks in results.multi_hand_landmarks:
                # 绘制关键点（修复括号问题）
                mp_drawing.draw_landmarks(
                    frame,
                    hand_landmarks,
                    mp_hands.HAND_CONNECTIONS,
                    mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                    mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
                )

                # ---------------------- 优化后的手指计数逻辑 ----------------------

                finger_count1 = 0
                finger_count2= 0
                h, w = frame.shape[:2]

                # 修复列表生成式括号问题
                landmark_points = [(int(lm.x * w), int(lm.y * h))
                                   for lm in hand_landmarks.landmark]

                # 拇指判断（优化角度计算）
                thumb_tip = landmark_points[mp_hands.HandLandmark.THUMB_TIP.value]
                thumb_ip = landmark_points[mp_hands.HandLandmark.THUMB_IP.value]
                thumb_mcp = landmark_points[mp_hands.HandLandmark.THUMB_MCP.value]

                # 向量点积计算角度（添加分母保护）
                vec1 = (thumb_ip[0] - thumb_mcp[0], thumb_ip[1] - thumb_mcp[1])
                vec2 = (thumb_tip[0] - thumb_ip[0], thumb_tip[1] - thumb_ip[1])
                dot_product = vec1[0] * vec2[0] + vec1[1] * vec2[1]
                denominator = (math.hypot(*vec1) * math.hypot(*vec2)) + 1e-6
                angle = math.degrees(math.acos(dot_product / denominator))

                # 其他手指判断（示例：食指）

                index_tip_y = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_TIP.value][1]
                index_pip_y = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_PIP.value][1]
                if index_tip_y < index_pip_y:  # 指尖在PIP关节上方
                    finger_count1 += 1
                index_tip_y1 = landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_TIP.value][1]
                index_pip_y1= landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_PIP.value][1]
                if index_tip_y1 < index_pip_y1:  # 指尖在PIP关节上方
                    finger_count2 += 1

                # 显示计数结果
                cv2.putText(frame, f"index: {finger_count1}", (10, 30),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
                cv2.putText(frame, f"middle: {finger_count2}", (10, 60),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
        cv2.imshow('Hand Tracking', frame)
        # cv2.imshow('Hand Tracking', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
        if cv2.waitKey(5) & 0xFF == 27:
            break

cap.release()
cv2.destroyAllWindows()

#第四版
import cv2
import mediapipe as mp
import math

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
with mp_hands.Hands(
        static_image_mode=False,
        max_num_hands=2,
        min_detection_confidence=0.7,
        min_tracking_confidence=0.5
) as hands:
    while cap.isOpened():
        success, frame = cap.read()
        if not success:
            break

        # 转换颜色空间并处理
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = hands.process(rgb_frame)

        if results.multi_hand_landmarks:
            for hand_index, hand_landmarks in enumerate(results.multi_hand_landmarks):
                # 获取手部标签（左手或右手）
                handedness = results.multi_handedness[hand_index].classification[0].label

                # 绘制关键点
                mp_drawing.draw_landmarks(
                    frame,
                    hand_landmarks,
                    mp_hands.HAND_CONNECTIONS,
                    mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                    mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
                )

                # 初始化手指计数
                finger_count = 0
                h, w = frame.shape[:2]

                # 获取所有关键点的像素坐标
                landmark_points = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]

                # ---------------------- 大拇指判断优化 ----------------------
                thumb_tip = landmark_points[mp_hands.HandLandmark.THUMB_TIP.value]
                thumb_ip = landmark_points[mp_hands.HandLandmark.THUMB_IP.value]
                thumb_mcp = landmark_points[mp_hands.HandLandmark.THUMB_MCP.value]

                # 判断大拇指是否伸展
                if handedness == "Right":
                    # 对于右手，如果 TIP 在 MCP 的左侧，则认为大拇指是伸展的
                    if thumb_tip[0] < thumb_mcp[0]:
                        finger_count += 1
                else:
                    # 对于左手，如果 TIP 在 MCP 的右侧，则认为大拇指是伸展的
                    if thumb_tip[0] > thumb_mcp[0]:
                        finger_count += 1

                # ---------------------- 其他手指判断 ----------------------
                fingers = [
                    mp_hands.HandLandmark.INDEX_FINGER_TIP,
                    mp_hands.HandLandmark.MIDDLE_FINGER_TIP,
                    mp_hands.HandLandmark.RING_FINGER_TIP,
                    mp_hands.HandLandmark.PINKY_TIP
                ]
                for finger in fingers:
                    tip_y = landmark_points[finger.value][1]
                    pip_y = landmark_points[finger.value - 2][1]  # PIP关节是TIP的前两个点
                    if tip_y < pip_y:  # 指尖在PIP关节上方
                        finger_count += 1

                # 显示计数结果
                if handedness == "Right":
                    y = 30  # 右手结果显示在 y=40 的位置
                else:
                    y = 70  # 左手结果显示在 y=60 的位置

                cv2.putText(frame, f"{handedness} Hand: {finger_count}", (10, y),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

        # 显示画面
        cv2.imshow('Hand Tracking', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()
#---------------------------------------------------------------------------------------------------------------------------
#第五版
import cv2
import mediapipe as mp
import pyautogui
import math
import time
import threading

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # 降低分辨率以提高帧率
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# 设置窗口名称并调整窗口大小
cv2.namedWindow('Hand Gesture Control', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Hand Gesture Control', 640, 480)  # 设置窗口大小为 1280x720

# 初始化pyautogui
pyautogui.FAILSAFE = False  # 禁用pyautogui的故障保护功能

# 全局变量用于多线程
frame = None
results = None
fps = 0

# 图像捕获线程
def capture_frame():
    global frame
    while cap.isOpened():
        success, img = cap.read()
        if not success:
            break
        frame = img  # 更新全局帧

# 图像处理线程
def process_frame():
    global results, fps
    with mp_hands.Hands(
            static_image_mode=False,
            max_num_hands=1,  # 只检测一只手
            min_detection_confidence=0.7,
            min_tracking_confidence=0.5
    ) as hands:
        while cap.isOpened():
            if frame is None:
                continue

            # 镜像模式：水平翻转帧
            flipped_frame = cv2.flip(frame, 1)

            # 转换颜色空间并处理
            rgb_frame = cv2.cvtColor(flipped_frame, cv2.COLOR_BGR2RGB)
            start_time = time.time()
            results = hands.process(rgb_frame)
            end_time = time.time()

            # 计算FPS
            fps = 1 / (end_time - start_time)

# 启动图像捕获线程
capture_thread = threading.Thread(target=capture_frame)
capture_thread.daemon = True
capture_thread.start()

# 启动图像处理线程
process_thread = threading.Thread(target=process_frame)
process_thread.daemon = True
process_thread.start()

while cap.isOpened():
    if frame is None or results is None:
        continue

    # 镜像模式：水平翻转帧
    flipped_frame = cv2.flip(frame, 1)

    # 绘制手势识别结果
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # 绘制关键点
            mp_drawing.draw_landmarks(
                flipped_frame,
                hand_landmarks,
                mp_hands.HAND_CONNECTIONS,
                mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
            )

            # 获取所有关键点的像素坐标
            h, w = flipped_frame.shape[:2]
            landmark_points = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]

            # 获取关键点坐标
            thumb_tip = landmark_points[mp_hands.HandLandmark.THUMB_TIP.value]
            index_tip = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_TIP.value]
            middle_tip = landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_TIP.value]
            ring_tip = landmark_points[mp_hands.HandLandmark.RING_FINGER_TIP.value]
            pinky_tip = landmark_points[mp_hands.HandLandmark.PINKY_TIP.value]
            wrist = landmark_points[mp_hands.HandLandmark.WRIST.value]

            # 计算手指是否伸展
            fingers = [
                (index_tip[1] < landmark_points[mp_hands.HandLandmark.INDEX_FINGER_PIP.value][1]),  # 食指
                (middle_tip[1] < landmark_points[mp_hands.HandLandmark.MIDDLE_FINGER_PIP.value][1]),  # 中指
                (ring_tip[1] < landmark_points[mp_hands.HandLandmark.RING_FINGER_PIP.value][1]),  # 无名指
                (pinky_tip[1] < landmark_points[mp_hands.HandLandmark.PINKY_PIP.value][1])  # 小指
            ]

            # 判断手势
            if all(fingers):  # 所有手指都伸展（手掌张开）
                # 模拟鼠标移动
                x, y = index_tip[0], index_tip[1]
                screen_width, screen_height = pyautogui.size()
                target_x = int((x / w) * screen_width)
                target_y = int((y / h) * screen_height)
                pyautogui.moveTo(target_x, target_y, duration=0.1)
                cv2.putText(flipped_frame, "Mouse Move", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

            elif not any(fingers):  # 所有手指都弯曲（握拳）
                # 模拟鼠标左键点击
                pyautogui.click()
                cv2.putText(flipped_frame, "Click", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

            elif fingers[0] and not any(fingers[1:]):  # 只有食指伸展
                # 模拟按下空格键
                pyautogui.press('space')
                cv2.putText(flipped_frame, "Space", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

            elif not fingers[0] and not fingers[1] and not fingers[2] and fingers[3]:  # 只有大拇指伸展
                # 模拟按下Alt+Tab切换窗口
                pyautogui.hotkey('alt', 'tab')
                cv2.putText(flipped_frame, "Alt+Tab", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示FPS
    cv2.putText(flipped_frame, f"FPS: {int(fps)}", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示画面
    cv2.imshow('Hand Gesture Control', flipped_frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
#----------------------------------------------------------------------------------------------------------------------------
#第六版
import cv2
import mediapipe as mp
import pyautogui
import time
import threading

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # 降低分辨率以提高帧率
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# 设置窗口名称并调整窗口大小
cv2.namedWindow('Hand Gesture Control', cv2.WINDOW_NORMAL)
cv2.resizeWindow('Hand Gesture Control', 640, 480)  # 设置窗口大小为 1280x720

# 初始化pyautogui
pyautogui.FAILSAFE = False  # 禁用pyautogui的故障保护功能

# 全局变量用于多线程
frame = None
results = None
fps = 0

# 初始化点击时间记录
last_click_time = 0

# 图像捕获线程
def capture_frame():
    global frame
    while cap.isOpened():
        success, img = cap.read()
        if not success:
            break
        frame = img  # 更新全局帧

# 图像处理线程
def process_frame():
    global results, fps
    with mp_hands.Hands(
            static_image_mode=False,
            max_num_hands=1,  # 只检测一只手
            min_detection_confidence=0.7,
            min_tracking_confidence=0.5
    ) as hands:
        while cap.isOpened():
            if frame is None:
                continue

            # 镜像模式：水平翻转帧
            flipped_frame = cv2.flip(frame, 1)

            # 转换颜色空间并处理
            rgb_frame = cv2.cvtColor(flipped_frame, cv2.COLOR_BGR2RGB)
            start_time = time.time()
            results = hands.process(rgb_frame)
            end_time = time.time()

            # 计算FPS
            fps = 1 / (end_time - start_time)

# 启动图像捕获线程
capture_thread = threading.Thread(target=capture_frame)
capture_thread.daemon = True
capture_thread.start()

# 启动图像处理线程
process_thread = threading.Thread(target=process_frame)
process_thread.daemon = True
process_thread.start()

while cap.isOpened():
    if frame is None or results is None:
        continue

    # 镜像模式：水平翻转帧
    flipped_frame = cv2.flip(frame, 1)

    # 绘制手势识别结果
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # 绘制关键点
            mp_drawing.draw_landmarks(
                flipped_frame,
                hand_landmarks,
                mp_hands.HAND_CONNECTIONS,
                mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
            )

            # 获取所有关键点的像素坐标
            h, w = flipped_frame.shape[:2]
            landmark_points = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]

            # 获取关键点坐标
            index_tip = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_TIP.value]
            index_pip = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_PIP.value]

            # 判断食指是否伸展
            if index_tip[1] < index_pip[1]:  # 食指伸展
                # 模拟鼠标移动
                x, y = index_tip[0], index_tip[1]
                screen_width, screen_height = pyautogui.size()
                target_x = int((x / w) * screen_width)
                target_y = int((y / h) * screen_height)
                pyautogui.moveTo(target_x, target_y, duration=0.1)
                cv2.putText(flipped_frame, "Mouse Move", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            else:  # 食指弯曲
                current_time = time.time()
                if current_time - last_click_time > 0.5:  # 每隔 0.5 秒才触发一次点击
                    # 模拟鼠标左键点击
                    pyautogui.click()
                    last_click_time = current_time  # 更新上次点击时间
                    cv2.putText(flipped_frame, "Click", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示FPS
    cv2.putText(flipped_frame, f"FPS: {int(fps)}", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示画面
    cv2.imshow('Hand Gesture Control', flipped_frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
#-------------------------------------------------------------------------------------------------------------------------------
#第七版
import cv2
import mediapipe as mp
import pyautogui
import time
import threading
from collections import deque

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # 提高分辨率
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# 初始化pyautogui
pyautogui.FAILSAFE = False  # 禁用pyautogui的故障保护功能

# 全局变量用于多线程
frame = None
results = None
fps = 0

# 初始化点击时间记录
last_click_time = 0

# 防抖参数
smooth_factor = 5  # 移动平均滤波的帧数
position_history = deque(maxlen=smooth_factor)  # 用于存储历史位置
dead_zone_threshold = 10  # 死区阈值，小于该值的移动将被忽略

# 图像捕获线程
def capture_frame():
    global frame
    while cap.isOpened():
        success, img = cap.read()
        if not success:
            break
        frame = img  # 更新全局帧

# 图像处理线程
def process_frame():
    global results, fps
    with mp_hands.Hands(
            static_image_mode=False,
            max_num_hands=1,  # 只检测一只手
            min_detection_confidence=0.7,
            min_tracking_confidence=0.5
    ) as hands:
        while cap.isOpened():
            if frame is None:
                continue

            # 关闭镜像模式
            flipped_frame = cv2.flip(frame, 1)  # 直接使用原始帧

            # 转换颜色空间并处理
            rgb_frame = cv2.cvtColor(flipped_frame, cv2.COLOR_BGR2RGB)
            start_time = time.time()
            results = hands.process(rgb_frame)
            end_time = time.time()

            # 计算FPS
            fps = 1 / (end_time - start_time)

# 启动图像捕获线程
capture_thread = threading.Thread(target=capture_frame)
capture_thread.daemon = True
capture_thread.start()

# 启动图像处理线程
process_thread = threading.Thread(target=process_frame)
process_thread.daemon = True
process_thread.start()

while cap.isOpened():
    if frame is None or results is None:
        continue

    # 关闭镜像模式
    flipped_frame = frame  # 直接使用原始帧

    # 绘制手势识别结果
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # 绘制关键点
            mp_drawing.draw_landmarks(
                flipped_frame,
                hand_landmarks,
                mp_hands.HAND_CONNECTIONS,
                mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),  # 关键点
                mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)  # 连接线
            )

            # 获取所有关键点的像素坐标
            h, w = flipped_frame.shape[:2]
            landmark_points = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]

            # 获取关键点坐标
            index_tip = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_TIP.value]
            index_pip = landmark_points[mp_hands.HandLandmark.INDEX_FINGER_PIP.value]

            # 判断食指是否伸展
            if index_tip[1] < index_pip[1]:  # 食指伸展
                # 模拟鼠标移动
                x, y = index_tip[0], index_tip[1]
                screen_width, screen_height = pyautogui.size()

                # 缩放因子，用于放大控制范围
                scale_factor = 1.5  # 例如，放大2倍

                # 计算目标鼠标位置
                target_x = int((x / w) * screen_width * scale_factor)
                target_y = int((y / h) * screen_height * scale_factor)

                # 确保目标位置在屏幕范围内
                target_x = max(0, min(target_x, screen_width - 1))
                target_y = max(0, min(target_y, screen_height - 1))

                # 添加当前位置到历史记录
                position_history.append((target_x, target_y))

                # 计算移动平均值
                if len(position_history) == smooth_factor:
                    avg_x = sum(p[0] for p in position_history) / smooth_factor
                    avg_y = sum(p[1] for p in position_history) / smooth_factor

                    # 死区控制：忽略微小移动
                    if abs(avg_x - target_x) > dead_zone_threshold or abs(avg_y - target_y) > dead_zone_threshold:
                        pyautogui.moveTo(int(avg_x), int(avg_y), duration=0.1)
                        cv2.putText(flipped_frame, "Mouse Move", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            else:  # 食指弯曲
                current_time = time.time()
                if current_time - last_click_time > 0.5:  # 每隔 0.5 秒才触发一次点击
                    # 模拟鼠标左键点击
                    pyautogui.click()
                    last_click_time = current_time  # 更新上次点击时间
                    cv2.putText(flipped_frame, "Click", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示FPS
    cv2.putText(flipped_frame, f"FPS: {int(fps)}", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    # 显示画面
    cv2.imshow('Hand Gesture Control', flipped_frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()
#-----------------------------------------------------------------------------------------------------------------------
#第八版
import cv2
import mediapipe as mp
import pyautogui
import time
import threading
from collections import deque

# 初始化MediaPipe手势模块
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils

# 配置摄像头
cap = cv2.VideoCapture(0)
if not cap.isOpened():
    raise Exception("无法打开摄像头，请检查摄像头连接。")

cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

# 初始化pyautogui
pyautogui.FAILSAFE = False  # 禁用故障保护

# 全局变量与线程锁
frame = None
results = None
fps = 0
frame_lock = threading.Lock()
results_lock = threading.Lock()

# 控制板参数
control_board_width = 400  # 控制板宽度
control_board_height = 300  # 控制板高度
control_board_x = 100  # 控制板左上角x坐标
control_board_y = 100  # 控制板左上角y坐标

# 防抖参数
smooth_factor = 5
position_history = deque(maxlen=smooth_factor)
dead_zone_threshold = 10

# 图像捕获线程
def capture_frame():
    global frame
    while cap.isOpened():
        success, img = cap.read()
        if not success:
            print("警告: 无法读取摄像头帧")
            break
        with frame_lock:
            frame = img

# 图像处理线程
def process_frame():
    global results, fps
    with mp_hands.Hands(
        static_image_mode=False,
        max_num_hands=1,
        min_detection_confidence=0.7,
        min_tracking_confidence=0.5
    ) as hands:
        while cap.isOpened():
            # 获取并翻转帧
            with frame_lock:
                if frame is None:
                    continue
                working_frame = cv2.flip(frame, 1)

            # 处理手势识别
            rgb_frame = cv2.cvtColor(working_frame, cv2.COLOR_BGR2RGB)
            start_time = time.time()
            processed_results = hands.process(rgb_frame)
            end_time = time.time()

            # 更新结果
            with results_lock:
                results = processed_results
                fps = 1 / (end_time - start_time)

# 启动线程
capture_thread = threading.Thread(target=capture_frame, daemon=True)
process_thread = threading.Thread(target=process_frame, daemon=True)
capture_thread.start()
process_thread.start()

try:
    while cap.isOpened():
        # 获取当前帧
        with frame_lock:
            if frame is None:
                continue
            display_frame = cv2.flip(frame, 1).copy()

        # 获取处理结果
        with results_lock:
            current_results = results
            current_fps = fps

        # 绘制控制板区域
        cv2.rectangle(display_frame,
                      (control_board_x, control_board_y),
                      (control_board_x + control_board_width, control_board_y + control_board_height),
                      (0, 255, 0), 2)

        # 手势识别处理
        if current_results and current_results.multi_hand_landmarks:
            for hand_landmarks in current_results.multi_hand_landmarks:
                # 绘制关键点
                mp_drawing.draw_landmarks(
                    display_frame,
                    hand_landmarks,
                    mp_hands.HAND_CONNECTIONS,
                    mp_drawing.DrawingSpec(color=(0,255,0), thickness=2),  # 关键点
                    mp_drawing.DrawingSpec(color=(0,0,255), thickness=2)   # 连接线
                )

                # 获取食指坐标
                h, w = display_frame.shape[:2]
                landmarks = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]
                tip = landmarks[mp_hands.HandLandmark.INDEX_FINGER_TIP]

                # 检查食指是否在控制板区域内
                if (control_board_x <= tip[0] <= control_board_x + control_board_width and
                    control_board_y <= tip[1] <= control_board_y + control_board_height):
                    # 计算控制板内相对位置
                    relative_x = tip[0] - control_board_x
                    relative_y = tip[1] - control_board_y

                    # 计算屏幕坐标
                    screen_w, screen_h = pyautogui.size()
                    target_x = int((relative_x / control_board_width) * screen_w)
                    target_y = int((relative_y / control_board_height) * screen_h)

                    # 防抖处理
                    position_history.append((target_x, target_y))
                    if len(position_history) == smooth_factor:
                        avg_x = sum(p[0] for p in position_history) // smooth_factor
                        avg_y = sum(p[1] for p in position_history) // smooth_factor

                        # 死区控制：忽略微小移动
                        if abs(avg_x - target_x) > dead_zone_threshold or \
                           abs(avg_y - target_y) > dead_zone_threshold:
                            pyautogui.moveTo(avg_x, avg_y, duration=0.1)
                            cv2.putText(display_frame, "Moving", (10,50),
                                      cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)

        # 显示FPS
        cv2.putText(display_frame, f"FPS: {int(current_fps)}", (10,100),
                  cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 2)

        # 显示窗口
        cv2.imshow('Gesture Mouse Control', display_frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

except Exception as e:
    print(f"程序异常: {e}")

finally:
    cap.release()
    cv2.destroyAllWindows()
    print("程序已正常退出")
#---------------------------------------------------------------------------------------------------------------------------
#第九版
import cv2
import mediapipe as mp
import pyautogui
import time
import threading
from collections import deque
import math

class GestureMouseControl:
    def __init__(self):
        self.cap = cv2.VideoCapture(0)
        if not self.cap.isOpened():
            raise Exception("无法打开摄像头，请检查摄像头连接。")

        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

        self.mp_hands = mp.solutions.hands
        self.mp_drawing = mp.solutions.drawing_utils
        self.hands = self.mp_hands.Hands(
            static_image_mode=False,
            max_num_hands=1,
            min_detection_confidence=0.7,
            min_tracking_confidence=0.5
        )

        self.frame = None
        self.results = None
        self.fps = 0
        self.frame_lock = threading.Lock()
        self.results_lock = threading.Lock()

        # 控制板参数
        self.control_board_width = 340
        self.control_board_height = 240
        self.control_board_x = 150
        self.control_board_y = 130

        # 边缘缓冲区域宽度
        self.edge_buffer = 50

        self.smooth_factor = 5
        self.position_history = deque(maxlen=self.smooth_factor)
        self.dead_zone_threshold = 10

        # 点击阈值（手指距离小于该值时触发点击）
        self.click_threshold = 30
        # 防抖标志
        self.left_clicked = False
        self.right_clicked = False

        self.running = True

        # 平滑滤波参数
        self.smoothing_factor = 0.5
        self.last_x, self.last_y = pyautogui.position()

    def capture_frame(self):
        while self.running:
            success, img = self.cap.read()
            if not success:
                print("警告: 无法读取摄像头帧")
                break
            with self.frame_lock:
                self.frame = img

    def process_frame(self):
        while self.running:
            with self.frame_lock:
                if self.frame is None:
                    continue
                working_frame = cv2.flip(self.frame, 1)

            rgb_frame = cv2.cvtColor(working_frame, cv2.COLOR_BGR2RGB)
            start_time = time.time()
            processed_results = self.hands.process(rgb_frame)
            end_time = time.time()

            with self.results_lock:
                self.results = processed_results
                self.fps = 1 / (end_time - start_time)

    def run(self):
        capture_thread = threading.Thread(target=self.capture_frame, daemon=True)
        process_thread = threading.Thread(target=self.process_frame, daemon=True)
        capture_thread.start()
        process_thread.start()

        try:
            while self.running:
                with self.frame_lock:
                    if self.frame is None:
                        continue
                    display_frame = cv2.flip(self.frame, 1).copy()

                with self.results_lock:
                    current_results = self.results
                    current_fps = self.fps

                self.draw_control_board(display_frame)
                self.process_gestures(display_frame, current_results)
                self.display_fps(display_frame, current_fps)

                cv2.imshow('Gesture Mouse Control', display_frame)
                if cv2.waitKey(1) & 0xFF == ord('q'):
                    self.running = False

        except Exception as e:
            print(f"程序异常: {e}")

        finally:
            self.cap.release()
            cv2.destroyAllWindows()
            print("程序已正常退出")

    def draw_control_board(self, frame):
        # 绘制控制板
        cv2.rectangle(frame,
                      (self.control_board_x, self.control_board_y),
                      (self.control_board_x + self.control_board_width, self.control_board_y + self.control_board_height),
                      (0, 255, 0), 2)

        # 绘制边缘缓冲区域
        cv2.rectangle(frame,
                      (self.control_board_x - self.edge_buffer, self.control_board_y - self.edge_buffer),
                      (self.control_board_x + self.control_board_width + self.edge_buffer, self.control_board_y + self.control_board_height + self.edge_buffer),
                      (0, 0, 255), 1)

    def process_gestures(self, frame, results):
        if results and results.multi_hand_landmarks:
            for hand_landmarks in results.multi_hand_landmarks:
                self.draw_landmarks(frame, hand_landmarks)
                self.move_mouse(frame, hand_landmarks)
                self.detect_clicks(frame, hand_landmarks)

    def draw_landmarks(self, frame, hand_landmarks):
        self.mp_drawing.draw_landmarks(
            frame,
            hand_landmarks,
            self.mp_hands.HAND_CONNECTIONS,
            self.mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2),
            self.mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2)
        )

    def move_mouse(self, frame, hand_landmarks):
        h, w = frame.shape[:2]
        landmarks = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]
        tip = landmarks[self.mp_hands.HandLandmark.INDEX_FINGER_TIP]

        # 检查手指是否在控制板或边缘缓冲区域内
        if (self.control_board_x - self.edge_buffer <= tip[0] <= self.control_board_x + self.control_board_width + self.edge_buffer and
            self.control_board_y - self.edge_buffer <= tip[1] <= self.control_board_y + self.control_board_height + self.edge_buffer):

            # 计算相对位置（包括缓冲区域）
            relative_x = tip[0] - (self.control_board_x - self.edge_buffer)
            relative_y = tip[1] - (self.control_board_y - self.edge_buffer)

            # 计算目标位置
            screen_w, screen_h = pyautogui.size()
            target_x = int((relative_x / (self.control_board_width + 2 * self.edge_buffer)) * screen_w)
            target_y = int((relative_y / (self.control_board_height + 2 * self.edge_buffer)) * screen_h)

            # 使用指数平滑滤波
            smoothed_x = self.last_x + self.smoothing_factor * (target_x - self.last_x)
            smoothed_y = self.last_y + self.smoothing_factor * (target_y - self.last_y)

            self.last_x, self.last_y = smoothed_x, smoothed_y

            # 检查是否超过死区阈值
            if abs(smoothed_x - target_x) > self.dead_zone_threshold or \
               abs(smoothed_y - target_y) > self.dead_zone_threshold:
                pyautogui.moveTo(int(smoothed_x), int(smoothed_y), duration=0.1)
                cv2.putText(frame, "Moving", (10, 50),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

    def detect_clicks(self, frame, hand_landmarks):
        h, w = frame.shape[:2]
        landmarks = [(int(lm.x * w), int(lm.y * h)) for lm in hand_landmarks.landmark]

        # 获取指尖坐标
        index_tip = landmarks[self.mp_hands.HandLandmark.INDEX_FINGER_TIP]
        thumb_tip = landmarks[self.mp_hands.HandLandmark.THUMB_TIP]
        middle_tip = landmarks[self.mp_hands.HandLandmark.MIDDLE_FINGER_TIP]

        # 计算食指和拇指的距离
        index_thumb_distance = math.hypot(index_tip[0] - thumb_tip[0], index_tip[1] - thumb_tip[1])
        # 计算中指和拇指的距离
        middle_thumb_distance = math.hypot(middle_tip[0] - thumb_tip[0], middle_tip[1] - thumb_tip[1])

        # 左键点击（食指和拇指接触）
        if index_thumb_distance < self.click_threshold:
            if not self.left_clicked:
                pyautogui.click(button='left')
                self.left_clicked = True
                cv2.putText(frame, "Left Click", (10, 150),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
        else:
            self.left_clicked = False

        # 右键点击（中指和拇指接触）
        if middle_thumb_distance < self.click_threshold:
            if not self.right_clicked:
                pyautogui.click(button='right')
                self.right_clicked = True
                cv2.putText(frame, "Right Click", (10, 200),
                            cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
        else:
            self.right_clicked = False

    def display_fps(self, frame, fps):
        cv2.putText(frame, f"FPS: {int(fps)}", (10, 100),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)

if __name__ == "__main__":
    gesture_mouse_control = GestureMouseControl()
    gesture_mouse_control.run()

免责：中间代码可能有错误（新人创作，轻点喷）

安装库可以转上一篇

901548
关注
基于mediapipe和opencv的手势控制电脑鼠标
m0_59151709的博客
03-03 1900
基于mediapipe,opencv,pyautogui的手势控制的虚拟鼠标
OpenCV教程：超详细的OpenCV入门教程，值得收藏
热门推荐
pythonandaiot的博客
05-10 13万+
OpenCV（Open Source Computer Vision Library）是一个开源的计算机视觉库，它提供了很多函数，这些函数非常高效地实现了计算机视觉算法（最基本的滤波到高级的物体检测皆有涵盖）。 OpenCV 使用 C/C++ 开发，同时也提供了 Python、Java、MATLAB 等其他语言的接口。 OpenCV 是跨平台的，可以在Windows、Linux、Mac OS、Android、iOS 等操作系统上运行。 OpenCV 的应用领域非常广泛，包括图像拼接、图像降噪、产品质检、..
js通过OpenCV获取小区边界
weixin_58372488的博客
03-07 1035
我们需要通过点击地图来进行获取地理对象边界。然而，单纯依靠用户直接点击地图，想要获取精确的地理对象边界，往往难以实现。于是，我们将目光转向图像处理的方法，试图从中找到解决方案。在对众多图像处理工具进行深入研究与对比后，发现 OpenCV 在解决这一问题上具有显著优势。
OpenCV57:级联分类器的训练
uncle_ll的博客
01-24 5979
目的 在本章中，将学习： 级联分类器的训练过程 学习函数： opencv_createsamples opencv_annotation opencv_traincascade opencv_visualisation 原理 使用弱分类器的增强级联包括两个主要阶段：训练阶段和检测阶段。对象检测教程中介绍了使用基于HAAR或LBP（中心点为阈值，大于它的设为1，小于它的设为0）模型的检测阶段。本文档概述了训练弱分类器的级联所需的函数。当前指南将逐步完成所有不同阶段： 收集训练数据 准备训练数据 训
OPENCV训练模型
俗科技的博客
05-25 5090
​ 使用Cascade Classifier包括两个主要阶段:训练阶段和检测阶段。需要用到的OpenCV应用程序:opencv_createssamples, opencv_annotation, opencv_traincascade和opencv_visualisation。opencv_createssamples和opencv_traincascade自OpenCV 4.0以来被禁用，但由于3.4和4.x的模型格式相同，因此可以采用3.4版本的程序进行模型训练。
OpenCV基础教程大全
qq_41854911的博客
12-16 5807
文章目录关于本教程OpenCV是什么？IPPICV 加速OpenCV有哪些应用？OpenCV 使用开源许可证什么是计算机视觉？人类的视觉计算机的视觉场景信息可以辅助计算机视觉使用统计的方法来对抗噪声OpenCV的起源（发展历程）OpenCV 目前的情况谁拥有OpenCVOpenCV包含的模块以及组成结构OpenCV下载和安装（包含所有平台）安装在 Windows 系统下安装 OpenCV从源代码编译 OpenCVLinux 系统下安装 OpenCVMac系统下安装 OpenCV从 Git 获取最新的 Ope
基于OpenCV的截图小程序
持久决心的博客
10-20 4004
基于OpenCV的截图小程序，可以处理图像或者视频，从中截取自己感兴趣的区域。像素级的操作，将图像中的感兴趣部分的原样复制出来，不会有压缩之类的问题。涉及到鼠标响应，视频进度条控制，非常全面的程序。
以VS2017+OpenCV3.4.7+opencv_contrib3.4.7 为例，用cmake编译，实现所有版本轻松编译，其他版本组合都可借鉴
weixin_48849976的博客
04-01 4115
以VS2017+OpenCV3.4.7+opencv_contrib3.4.7 cmake编译，实现所有版本轻松编译 说在前面：重新编译opencv,opencv_contrib3.4.7是为了做项目需要适用opencv的跟踪算法，但是因为版权原因opencv官方没有公布，但是在git_hub上有opencv_contrib3.4.7扩展包，小编研究了一天摸透了所有的方法，网上很多编译教程，我发现多多少少都有小伙伴没能成功编译，现在详细记得把流程过一遍，保证不出错。以VS2017 Opencv3.4.7为例
opencv级联增强分类器训练流程--python实现
my_name_is_learn的博客
05-26 1337
级联增强分类器可以实现目标检测，本文主要详细地讲解如何使用python和opencv来实现这个过程，花了不少时间整理，耐心读完肯定收获满满
C++&&Opencv实现控制台字符动画的方法
08-18
总而言之，通过使用C++结合OpenCV库，我们可以实现将图片中的颜色信息转换为控制台中的字符动画，尽管在这个过程中涉及到一些图像处理和Windows API调用的复杂性，但这些技术都是可以逐步掌握和优化的。通过不断的...
python opencv手势数字识别左右手检测虚拟鼠标检测
04-27
在本项目中，我们主要探讨的是如何利用Python与OpenCV库进行手势识别，特别是数字手势的识别，以及区分左右手，同时实现虚拟鼠标的功能。OpenCV是一个强大的计算机视觉库，广泛应用于图像处理和计算机视觉任务。 1....
人机交互项目基于openCV的手势识别控制的打地鼠游戏源代码+数据+项目报告+演示视频，代码有详细注释
08-09
手势识别：通过识别手指的骨节点位置状态对不同的手势进行判定，进而实现不同的光标操作。通过接触判定对动画地鼠进行打击。 本实验中，主要利用Python语言调用mediapipe库，对8号骨节点（食指的顶部节点）和12号骨...
OpenCV中的SIFT特征提取
zdx2585503940的博客
04-25 1519
尺度不变性：在不同尺度的图像中都能检测到相同的特征点旋转不变性：不受图像旋转的影响光照鲁棒性：对光照变化不敏感视角部分不变性：能够处理一定程度的视角变化SIFT作为计算机视觉领域的里程碑算法，尽管已有20多年历史，但其核心思想仍影响着现代特征提取方法的发展。通过OpenCV的简洁接口，我们可以轻松地将这一强大工具应用到各种视觉任务中。理解SIFT的原理和实现，对于掌握更先进的视觉算法也大有裨益。
OpenCV 图形API（71）图像与通道拼接函数-----从图像（GMat）中裁剪出一个矩形区域的操作函数 crop()
jndingxin的专栏
04-29 606
裁剪一个2D矩阵。 该函数根据给定的 cv::Rect 裁剪矩阵。 输出矩阵必须与输入矩阵具有相同的深度，大小由给定的矩形大小指定。
OpenCV第6课 图像处理之几何变换（缩放）
嵌入式老牛的博客
04-26 1329
图像几何变换又称为图像空间变换，它将一幅图像中的坐标位置映射到另一幅图像中的新坐标位置。几何变换并不改变图像的像素值，只是在图像平面上进行像素的重新安排。图像缩放，是指对图像的大小进行调整的过程。其中dst代表输出的目标图像，该图像的类型与src相同，其大小为dsize（当该值非零时），或者可以通过src.size()、fx、fy计算得到。首先对源图像附近的4×4近邻区域进行三次样条拟合，然后将目标像素对应的三次样条值作为目标图像对应像点的值。区域插值，根据当前像素点周边区域的像实现当前像素点的采样。
OpenCV 图形API（65）图像结构分析和形状描述符------拟合二维点集的直线函数 fitLine2D()
jndingxin的专栏
04-27 1045
拟合一条直线到2D点集。
OpenCV的grabCut算法分割图像
最新发布
brucexia的专栏
04-30 750
grabCut算法是Graphcut算法的改进，Graphcut是一种直接基于图割算法的图像分割技术，只需确认前景和背景的输入，该算法就可以完成前景和背景的最优分割。其用法很简单，只需输入一幅图像，并对一些像素进行标记，指明其属于背景或前景，算法就会根据这些局部标记计算出整个图像中前景和背景的分割线。函数compare在两个图像之间进行逐像素的比较，并输出比较的结果。（4）根据我们给的数据，GMM学习和创建新的像素分布，未知像素被标为可能的前景或可能的背景（根据其他硬标记像素的颜色统计和它们之间的关系）。
OpenCV 图形API（74）图像与通道拼接函数-----合并三个单通道图像（GMat）为一个多通道图像的函数merge3()
jndingxin的专栏
04-30 237
从3个单通道矩阵创建一个3通道矩阵。
从像素到驾驶决策：Python与OpenCV赋能自动驾驶图像识别
Echo_Wish
04-26 194
Python与OpenCV的结合不仅是自动驾驶图像识别的一种技术手段，更是一种创新思维。通过高效的图像处理算法与深度学习模型，我们能够让机器具备类人视觉，为自动驾驶技术的普及创造可能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值