import cv2
image = cv2.imread("screensho123t.jpg")
cv2.imshow("image",image)
cv2.waitKey(0)
if cv2.waitKey(1) & 0xFF == ord("q"):
    cv2.destroyAllWindows()

import cv2
import time
import os

def capture_image_from_camera():
    """
    从摄像头捕获单张图像并保存
    """
    # 创建保存图像的目录
    if not os.path.exists('captured_images'):
        os.makedirs('captured_images')
    
    # 初始化摄像头 (0 表示默认摄像头)
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    print("按 's' 键保存图像，按 'q' 键退出")
    
    while True:
        # 读取一帧
        ret, frame = cap.read()
        
        if not ret:
            print("无法获取图像帧")
            break
        
        # 显示图像
        cv2.imshow('Camera - Press s to save, q to quit', frame)
        
        # 等待键盘输入
        key = cv2.waitKey(1) & 0xFF
        
        if key == ord('s'):  # 保存图像
            timestamp = time.strftime("%Y%m%d_%H%M%S")
            filename = f"captured_images/image_{timestamp}.jpg"
            cv2.imwrite(filename, frame)
            print(f"图像已保存为 {filename}")
        
        elif key == ord('q'):  # 退出
            break
    
    # 释放资源
    cap.release()
    cv2.destroyAllWindows()

def record_video_from_camera():
    """
    从摄像头录制视频并保存
    """
    # 创建保存视频的目录
    if not os.path.exists('recorded_videos'):
        os.makedirs('recorded_videos')
    
    # 初始化摄像头
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    # 获取摄像头分辨率
    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    fps = 30  # 帧率
    
    # 定义视频编码器和创建 VideoWriter 对象
    timestamp = time.strftime("%Y%m%d_%H%M%S")
    video_filename = f"recorded_videos/video_{timestamp}.mp4"
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4 编码器
    out = cv2.VideoWriter(video_filename, fourcc, fps, (frame_width, frame_height))
    
    print(f"开始录制视频，按 'q' 键停止并保存到 {video_filename}")
    print("录制中...")
    
    recording = True
    while recording:
        ret, frame = cap.read()
        
        if not ret:
            print("无法获取图像帧")
            break
        
        # 写入视频文件
        out.write(frame)
        
        # 显示录制画面
        cv2.imshow('Recording - Press q to stop', frame)
        
        # 检查是否按下 q 键
        if cv2.waitKey(1) & 0xFF == ord('q'):
            recording = False
    
    print("视频录制完成")
    
    # 释放资源
    cap.release()
    out.release()
    cv2.destroyAllWindows()

def display_live_camera_feed():
    """
    显示实时摄像头画面
    """
    # 初始化摄像头
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    print("显示实时摄像头画面，按 'q' 键退出")
    
    while True:
        ret, frame = cap.read()
        
        if not ret:
            print("无法获取图像帧")
            break
        
        # 显示图像
        cv2.imshow('Live Camera Feed - Press q to quit', frame)
        
        # 检查是否按下 q 键
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    # 释放资源
    cap.release()
    cv2.destroyAllWindows()

def main():
    print("OpenCV 图像与视频采集 Demo")
    print("请选择操作:")
    print("1. 显示实时摄像头画面")
    print("2. 捕获单张图像")
    print("3. 录制视频")
    print("4. 退出")
    
    while True:
        choice = input("请输入选项 (1-4): ")
        
        if choice == '1':
            display_live_camera_feed()
        elif choice == '2':
            capture_image_from_camera()
        elif choice == '3':
            record_video_from_camera()
        elif choice == '4':
            print("程序退出")
            break
        else:
            print("无效输入，请重新选择")

if __name__ == "__main__":
    main()

import cv2
import numpy as np

def image_binarization():
    """
    图像二值化演示
    """
    # 读取图像（转换为灰度图）
    img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)
    
    if img is None:
        print("无法加载图像，请检查文件路径")
        return
    
    # 定义阈值和最大值
    threshold_value = 127
    max_val = 255
    
    # 1. 基本阈值处理（二进制阈值化）
    _, binary = cv2.threshold(img, threshold_value, max_val, cv2.THRESH_BINARY)
    
    # 2. 反二进制阈值化
    _, binary_inv = cv2.threshold(img, threshold_value, max_val, cv2.THRESH_BINARY_INV)
    
    # 3. 截断阈值化
    _, truncated = cv2.threshold(img, threshold_value, max_val, cv2.THRESH_TRUNC)
    
    # 4. 阈值化为0
    _, to_zero = cv2.threshold(img, threshold_value, max_val, cv2.THRESH_TOZERO)
    
    # 5. 反阈值化为0
    _, to_zero_inv = cv2.threshold(img, threshold_value, max_val, cv2.THRESH_TOZERO_INV)
    
    # 6. 大津算法自动确定阈值
    _, otsu = cv2.threshold(img, 0, max_val, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    # 显示所有结果
    cv2.imshow('Original', img)
    cv2.imshow('Binary', binary)
    cv2.imshow('Binary Inv', binary_inv)
    cv2.imshow('Truncated', truncated)
    cv2.imshow('To Zero', to_zero)
    cv2.imshow('To Zero Inv', to_zero_inv)
    cv2.imshow('Otsu', otsu)
    
    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def live_camera_binarization():
    """
    实时摄像头二值化演示
    """
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    print("实时摄像头二值化演示")
    print("按键说明:")
    print("1-5: 切换不同阈值方法")

import cv2
import numpy as np

def image_blur_demo():
    """
    图像模糊处理演示（静态图像）
    """
    # 读取图像
    img = cv2.imread('image.jpg')
    
    if img is None:
        print("无法加载图像，请检查文件路径")
        return
    
    # 1. 均值模糊 (Averaging)
    blur_avg = cv2.blur(img, (5, 5))
    
    # 2. 高斯模糊 (Gaussian Blur)
    blur_gaussian = cv2.GaussianBlur(img, (5, 5), 0)
    
    # 3. 中值模糊 (Median Blur) - 对椒盐噪声特别有效
    blur_median = cv2.medianBlur(img, 5)
    
    # 4. 双边滤波 (Bilateral Filter) - 能保留边缘
    blur_bilateral = cv2.bilateralFilter(img, 9, 75, 75)
    
    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Average Blur', blur_avg)
    cv2.imshow('Gaussian Blur', blur_gaussian)
    cv2.imshow('Median Blur', blur_median)
    cv2.imshow('Bilateral Filter', blur_bilateral)
    
    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def live_camera_blur_demo():
    """
    实时摄像头模糊处理演示
    """
    cap = cv2.VideoCapture(0)
    
    if not cap.isOpened():
        print("无法打开摄像头")
        return
    
    print("实时摄像头模糊处理演示")
    print("按键说明:")
    print("1: 均值模糊")
    print("2: 高斯模糊")
    print("3: 中值模糊")
    print("4: 双边滤波")
    print("0: 原始图像")
    print("q: 退出")
    
    # 初始模糊类型
    blur_type = 0  # 0:原始, 1:均值, 2:高斯, 3:中值, 4:双边
    
    while True:
        ret, frame = cap.read()
        if not ret:
            print("无法获取图像帧")
            break
        
        # 根据选择应用不同的模糊方法
        if blur_type == 1:
            processed = cv2.blur(frame, (15, 15))
            title = "Average Blur (1)"
        elif blur_type == 2:
            processed = cv2.GaussianBlur(frame, (15, 15), 0)
            title = "Gaussian Blur (2)"
        elif blur_type == 3:
            processed = cv2.medianBlur(frame, 15)
            title = "Median Blur (3)"
        elif blur_type == 4:
            processed = cv2.bilateralFilter(frame, 15, 75, 75)
            title = "Bilateral Filter (4)"
        else:
            processed = frame.copy()
            title = "Original (0)"
        
        # 显示结果
        cv2.imshow('Blur Demo - ' + title, processed)
        
        # 处理键盘输入
        key = cv2.waitKey(1) & 0xFF
        if key == ord('q'):
            break
        elif key == ord('0'):
            blur_type = 0
        elif key == ord('1'):
            blur_type = 1
        elif key == ord('2'):
            blur_type = 2
        elif key == ord('3'):
            blur_type = 3
        elif key == ord('4'):
            blur_type = 4
    
    cap.release()
    cv2.destroyAllWindows()

def add_noise_and_denoise_demo():
    """
    添加噪声并去噪演示
    """
    img = cv2.imread('image.jpg')
    
    if img is None:
        print("无法加载图像，请检查文件路径")
        return
    
    # 添加高斯噪声
    mean = 0
    var = 100
    sigma = var ** 0.5
    gaussian = np.random.normal(mean, sigma, img.shape)
    noisy_img = np.clip(img + gaussian, 0, 255).astype(np.uint8)
    
    # 添加椒盐噪声
    def add_salt_pepper(image, amount=0.05):
        out = image.copy()
        # 盐噪声 (白色)
        num_salt = np.ceil(amount * image.size * 0.5)
        coords = [np.random.randint(0, i-1, int(num_salt)) for i in image.shape]
        out[coords[0], coords[1], coords[2]] = 255
        
        # 椒噪声 (黑色)
        num_pepper = np.ceil(amount * image.size * 0.5)
        coords = [np.random.randint(0, i-1, int(num_pepper)) for i in image.shape]
        out[coords[0], coords[1], coords[2]] = 0
        return out
    
    salt_pepper_img = add_salt_pepper(img)
    
    # 去噪处理
    denoised_gaussian = cv2.GaussianBlur(noisy_img, (5, 5), 0)
    denoised_median = cv2.medianBlur(salt_pepper_img, 5)
    
    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Gaussian Noise', noisy_img)
    cv2.imshow('Denoised (Gaussian Blur)', denoised_gaussian)
    cv2.imshow('Salt & Pepper Noise', salt_pepper_img)
    cv2.imshow('Denoised (Median Blur)', denoised_median)
    
    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def main():
    print("OpenCV 图像模糊处理演示")
    print("请选择演示模式:")
    print("1. 图像文件模糊处理")
    print("2. 实时摄像头模糊处理")
    print("3. 噪声添加与去噪演示")
    
    choice = input("请输入选项 (1-3): ")
    
    if choice == '1':
        image_blur_demo()
    elif choice == '2':
        live_camera_blur_demo()
    elif choice == '3':
        add_noise_and_denoise_demo()
    else:
        print("无效输入")

if __name__ == "__main__":
    main()

import cv2
import numpy as np


def image_erosion_demo():
    """
    图像腐蚀操作演示（静态图像）
    """
    # 读取图像（转换为灰度图）
    img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

    if img is None:
        print("无法加载图像，请检查文件路径")
        return

    # 二值化处理（便于演示腐蚀效果）
    _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

    # 定义不同形状的结构元素（kernel）
    kernel_rect = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
    kernel_cross = cv2.getStructuringElement(cv2.MORPH_CROSS, (5, 5))
    kernel_ellipse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))

    # 应用不同kernel的腐蚀操作
    erosion_rect = cv2.erode(binary, kernel_rect, iterations=1)
    erosion_cross = cv2.erode(binary, kernel_cross, iterations=1)
    erosion_ellipse = cv2.erode(binary, kernel_ellipse, iterations=1)

    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Binary', binary)
    cv2.imshow('Erosion (Rectangle Kernel)', erosion_rect)
    cv2.imshow('Erosion (Cross Kernel)', erosion_cross)
    cv2.imshow('Erosion (Ellipse Kernel)', erosion_ellipse)

    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def live_camera_erosion_demo():
    """
    实时摄像头腐蚀操作演示
    """
    cap = cv2.VideoCapture(0)

    if not cap.isOpened():
        print("无法打开摄像头")
        return

    print("实时摄像头腐蚀操作演示")
    print("按键说明:")
    print("1: 矩形结构元素")
    print("2: 十字形结构元素")
    print("3: 椭圆形结构元素")
    print("0: 原始图像")
    print("+/-: 增加/减少腐蚀程度")
    print("q: 退出")

    # 初始参数
    kernel_type = 1  # 1:矩形, 2:十字形, 3:椭圆形
    iterations = 1  # 腐蚀次数
    kernel_size = 5  # 结构元素大小

    while True:
        ret, frame = cap.read()
        if not ret:
            print("无法获取图像帧")
            break

        # 转换为灰度图并二值化
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

        # 根据选择创建不同的结构元素
        if kernel_type == 1:
            kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_size, kernel_size))
            title = f"Rect Kernel (Size:{kernel_size}, Iter:{iterations})"
        elif kernel_type == 2:
            kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (kernel_size, kernel_size))
            title = f"Cross Kernel (Size:{kernel_size}, Iter:{iterations})"
        elif kernel_type == 3:
            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
            title = f"Ellipse Kernel (Size:{kernel_size}, Iter:{iterations})"
        else:
            kernel = None

        # 应用腐蚀操作
        if kernel is not None:
            processed = cv2.erode(binary, kernel, iterations=iterations)
        else:
            processed = binary.copy()
            title = "Original"

        # 显示结果
        cv2.imshow('Erosion Demo - ' + title, processed)

        # 处理键盘输入
        key = cv2.waitKey(1) & 0xFF
        if key == ord('q'):
            break
        elif key == ord('0'):
            kernel_type = 0
        elif key == ord('1'):
            kernel_type = 1
        elif key == ord('2'):
            kernel_type = 2
        elif key == ord('3'):
            kernel_type = 3
        elif key == ord('+'):
            iterations = min(iterations + 1, 10)
        elif key == ord('-'):
            iterations = max(iterations - 1, 1)
        elif key == ord('['):
            kernel_size = max(kernel_size - 2, 3)
        elif key == ord(']'):
            kernel_size = min(kernel_size + 2, 21)

    cap.release()
    cv2.destroyAllWindows()


def erosion_visualization():
    """
    腐蚀操作可视化演示（使用自定义图像）
    """
    # 创建测试图像（白色背景，黑色文字）
    img = np.ones((300, 400), dtype=np.uint8) * 255
    cv2.putText(img, 'OpenCV', (50, 150), cv2.FONT_HERSHEY_SIMPLEX, 3, 0, 10)

    # 定义结构元素
    kernel = np.ones((15, 15), np.uint8)

    # 应用腐蚀
    erosion = cv2.erode(img, kernel, iterations=1)

    # 显示过程动画
    print("腐蚀过程可视化（按任意键继续）...")
    cv2.imshow('Original', img)
    cv2.waitKey(500)

    # 显示kernel
    kernel_display = cv2.resize(kernel * 255, (200, 200), interpolation=cv2.INTER_NEAREST)
    cv2.imshow('Kernel (15x15)', kernel_display)
    cv2.waitKey(500)

    # 显示腐蚀结果
    cv2.imshow('After Erosion', erosion)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def main():
    print("OpenCV 图像腐蚀操作演示")
    print("请选择演示模式:")
    print("1. 图像文件腐蚀操作")
    print("2. 实时摄像头腐蚀操作")
    print("3. 腐蚀操作可视化演示")

    choice = input("请输入选项 (1-3): ")

    if choice == '1':
        image_erosion_demo()
    elif choice == '2':
        live_camera_erosion_demo()
    elif choice == '3':
        erosion_visualization()
    else:
        print("无效输入")


if __name__ == "__main__":
    main()

import cv2
import numpy as np

# 创建不同形状的卷积核
size = (7,7)  # 可以修改为(3,3)、(5,5)等观察效果

kernel_rect = cv2.getStructuringElement(cv2.MORPH_RECT, size)
kernel_ellipse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, size)
kernel_cross = cv2.getStructuringElement(cv2.MORPH_CROSS, size)

# 可视化卷积核
def visualize_kernel(kernel, title):
    # 放大显示
    display = cv2.resize(kernel*255, (200,200), interpolation=cv2.INTER_NEAREST)
    cv2.imshow(title, display)
    print(title)
    print(kernel)  # 打印矩阵值

visualize_kernel(kernel_rect, "Rectangle Kernel")
visualize_kernel(kernel_ellipse, "Ellipse Kernel")
visualize_kernel(kernel_cross, "Cross Kernel")

cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np


def image_dilation_demo():
    """
    图像膨胀操作演示（静态图像）
    """
    # 读取图像（转换为灰度图）
    img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

    if img is None:
        print("无法加载图像，请检查文件路径")
        return

    # 二值化处理（便于演示膨胀效果）
    _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY_INV)  # 反转以便观察膨胀效果

    # 定义不同形状的结构元素（kernel）
    kernel_rect = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
    kernel_cross = cv2.getStructuringElement(cv2.MORPH_CROSS, (5, 5))
    kernel_ellipse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))

    # 应用不同kernel的膨胀操作
    dilation_rect = cv2.dilate(binary, kernel_rect, iterations=1)
    dilation_cross = cv2.dilate(binary, kernel_cross, iterations=1)
    dilation_ellipse = cv2.dilate(binary, kernel_ellipse, iterations=1)

    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Binary (Inverted)', binary)
    cv2.imshow('Dilation (Rectangle Kernel)', dilation_rect)
    cv2.imshow('Dilation (Cross Kernel)', dilation_cross)
    cv2.imshow('Dilation (Ellipse Kernel)', dilation_ellipse)

    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def live_camera_dilation_demo():
    """
    实时摄像头膨胀操作演示
    """
    cap = cv2.VideoCapture(0)

    if not cap.isOpened():
        print("无法打开摄像头")
        return

    print("实时摄像头膨胀操作演示")
    print("按键说明:")
    print("1: 矩形结构元素")
    print("2: 十字形结构元素")
    print("3: 椭圆形结构元素")
    print("0: 原始图像")
    print("+/-: 增加/减少膨胀程度")
    print("q: 退出")

    # 初始参数
    kernel_type = 1  # 1:矩形, 2:十字形, 3:椭圆形
    iterations = 1  # 膨胀次数
    kernel_size = 5  # 结构元素大小

    while True:
        ret, frame = cap.read()
        if not ret:
            print("无法获取图像帧")
            break

        # 转换为灰度图并二值化（反转以便观察膨胀效果）
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY_INV)

        # 根据选择创建不同的结构元素
        if kernel_type == 1:
            kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_size, kernel_size))
            title = f"Rect Kernel (Size:{kernel_size}, Iter:{iterations})"
        elif kernel_type == 2:
            kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (kernel_size, kernel_size))
            title = f"Cross Kernel (Size:{kernel_size}, Iter:{iterations})"
        elif kernel_type == 3:
            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
            title = f"Ellipse Kernel (Size:{kernel_size}, Iter:{iterations})"
        else:
            kernel = None

        # 应用膨胀操作
        if kernel is not None:
            processed = cv2.dilate(binary, kernel, iterations=iterations)
        else:
            processed = binary.copy()
            title = "Original"

        # 显示结果
        cv2.imshow('Dilation Demo - ' + title, processed)

        # 处理键盘输入
        key = cv2.waitKey(1) & 0xFF
        if key == ord('q'):
            break
        elif key == ord('0'):
            kernel_type = 0
        elif key == ord('1'):
            kernel_type = 1
        elif key == ord('2'):
            kernel_type = 2
        elif key == ord('3'):
            kernel_type = 3
        elif key == ord('+'):
            iterations = min(iterations + 1, 10)
        elif key == ord('-'):
            iterations = max(iterations - 1, 1)
        elif key == ord('['):
            kernel_size = max(kernel_size - 2, 3)
        elif key == ord(']'):
            kernel_size = min(kernel_size + 2, 21)

    cap.release()
    cv2.destroyAllWindows()


def dilation_visualization():
    """
    膨胀操作可视化演示（使用自定义图像）
    """
    # 创建测试图像（白色背景，黑色文字）
    img = np.ones((300, 400), dtype=np.uint8) * 255
    cv2.putText(img, 'OpenCV', (50, 150), cv2.FONT_HERSHEY_SIMPLEX, 3, 0, 10)

    # 反转图像以便观察膨胀效果
    binary = cv2.bitwise_not(img)

    # 定义结构元素
    kernel = np.ones((15, 15), np.uint8)

    # 应用膨胀
    dilation = cv2.dilate(binary, kernel, iterations=1)

    # 显示过程动画
    print("膨胀过程可视化（按任意键继续）...")
    cv2.imshow('Original', img)
    cv2.waitKey(500)
    cv2.imshow('Binary (Inverted)', binary)
    cv2.waitKey(500)

    # 显示kernel
    kernel_display = cv2.resize(kernel * 255, (200, 200), interpolation=cv2.INTER_NEAREST)
    cv2.imshow('Kernel (15x15)', kernel_display)
    cv2.waitKey(500)

    # 显示膨胀结果
    cv2.imshow('After Dilation', dilation)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def main():
    print("OpenCV 图像膨胀操作演示")
    print("请选择演示模式:")
    print("1. 图像文件膨胀操作")
    print("2. 实时摄像头膨胀操作")
    print("3. 膨胀操作可视化演示")

    choice = input("请输入选项 (1-3): ")

    if choice == '1':
        image_dilation_demo()
    elif choice == '2':
        live_camera_dilation_demo()
    elif choice == '3':
        dilation_visualization()
    else:
        print("无效输入")


if __name__ == "__main__":
    main()

import cv2
import numpy as np


def opening_operation_demo():
    """
    开运算演示（先腐蚀后膨胀）
    """
    # 读取图像（转换为灰度图）
    img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

    if img is None:
        print("无法加载图像，请检查文件路径")
        return

    # 二值化处理
    _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

    # 定义结构元素
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))

    # 方法1：分步实现开运算
    erosion = cv2.erode(binary, kernel)  # 先腐蚀
    opening_step = cv2.dilate(erosion, kernel)  # 后膨胀

    # 方法2：直接使用开运算函数
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)

    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Binary', binary)
    cv2.imshow('Erosion (Step 1)', erosion)
    cv2.imshow('Opening (Step by Step)', opening_step)
    cv2.imshow('Opening (Direct Function)', opening)

    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def closing_operation_demo():
    """
    闭运算演示（先膨胀后腐蚀）
    """
    # 读取图像（转换为灰度图）
    img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

    if img is None:
        print("无法加载图像，请检查文件路径")
        return

    # 二值化处理
    _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)

    # 定义结构元素
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))

    # 方法1：分步实现闭运算
    dilation = cv2.dilate(binary, kernel)  # 先膨胀
    closing_step = cv2.erode(dilation, kernel)  # 后腐蚀

    # 方法2：直接使用闭运算函数
    closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)

    # 显示结果
    cv2.imshow('Original', img)
    cv2.imshow('Binary', binary)
    cv2.imshow('Dilation (Step 1)', dilation)
    cv2.imshow('Closing (Step by Step)', closing_step)
    cv2.imshow('Closing (Direct Function)', closing)

    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def live_morphological_operations():
    """
    实时摄像头形态学操作演示
    """
    cap = cv2.VideoCapture(0)

    if not cap.isOpened():
        print("无法打开摄像头")
        return

    print("实时摄像头形态学操作演示")
    print("按键说明:")
    print("o: 开运算")
    print("c: 闭运算")
    print("e: 仅腐蚀")
    print("d: 仅膨胀")
    print("0: 原始图像")
    print("+/-: 增加/减少操作强度")
    print("q: 退出")

    # 初始参数
    operation = 0  # 0:原始, 1:开运算, 2:闭运算, 3:腐蚀, 4:膨胀
    kernel_size = 5

    while True:
        ret, frame = cap.read()
        if not ret:
            print("无法获取图像帧")
            break

        # 转换为灰度图并二值化
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

        # 创建结构元素
        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))

        # 应用选择的形态学操作
        if operation == 1:
            processed = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
            title = f"Opening (Size:{kernel_size})"
        elif operation == 2:
            processed = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
            title = f"Closing (Size:{kernel_size})"
        elif operation == 3:
            processed = cv2.erode(binary, kernel)
            title = f"Erosion (Size:{kernel_size})"
        elif operation == 4:
            processed = cv2.dilate(binary, kernel)
            title = f"Dilation (Size:{kernel_size})"
        else:
            processed = binary.copy()
            title = "Original"

        # 显示结果
        cv2.imshow('Morphological Operations - ' + title, processed)

        # 处理键盘输入
        key = cv2.waitKey(1) & 0xFF
        if key == ord('q'):
            break
        elif key == ord('0'):
            operation = 0
        elif key == ord('o'):
            operation = 1
        elif key == ord('c'):
            operation = 2
        elif key == ord('e'):
            operation = 3
        elif key == ord('d'):
            operation = 4
        elif key == ord('+'):
            kernel_size = min(kernel_size + 2, 21)
        elif key == ord('-'):
            kernel_size = max(kernel_size - 2, 3)

    cap.release()
    cv2.destroyAllWindows()


def main():
    print("OpenCV 形态学操作演示")
    print("请选择演示模式:")
    print("1. 开运算演示")
    print("2. 闭运算演示")
    print("3. 实时摄像头形态学操作")

    choice = input("请输入选项 (1-3): ")

    if choice == '1':
        opening_operation_demo()
    elif choice == '2':
        closing_operation_demo()
    elif choice == '3':
        live_morphological_operations()
    else:
        print("无效输入")


if __name__ == "__main__":
    main()

import cv2
import numpy as np

# 高级形态学运算演示
def advanced_morphology_demo():
    img = cv2.imread('image.png', 0)
    _, binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
    
    # 形态学梯度
    gradient = cv2.morphologyEx(binary, cv2.MORPH_GRADIENT, kernel)
    
    # 顶帽变换
    tophat = cv2.morphologyEx(binary, cv2.MORPH_TOPHAT, kernel)
    
    # 黑帽变换
    blackhat = cv2.morphologyEx(binary, cv2.MORPH_BLACKHAT, kernel)
    
    # 显示结果
    cv2.imshow('Original', binary)
    cv2.imshow('Gradient', gradient)
    cv2.imshow('Top-hat', tophat)
    cv2.imshow('Black-hat', blackhat)
    cv2.waitKey(0)

# 形态学重建实现
def morphological_reconstruction(marker, mask, kernel_size=3):
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size,kernel_size))
    while True:
        expanded = cv2.dilate(marker, kernel)
        expanded = cv2.bitwise_and(expanded, mask)
        if cv2.countNonZero(expanded - marker) == 0:
            break
        marker = expanded.copy()
    return marker

# 分水岭算法示例
def watershed_demo():
    img = cv2.imread('cells.png')
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
    
    # 去除噪声
    kernel = np.ones((3,3), np.uint8)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel, iterations=2)
    
    # 确定背景区域
    sure_bg = cv2.dilate(opening, kernel, iterations=3)
    
    # 寻找确定前景区域
    dist_transform = cv2.distanceTransform(opening, cv2.DIST_L2, 5)
    _, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)
    
    # 标记创建
    sure_fg = np.uint8(sure_fg)
    unknown = cv2.subtract(sure_bg, sure_fg)
    _, markers = cv2.connectedComponents(sure_fg)
    markers += 1
    markers[unknown==255] = 0
    
    # 分水岭算法
    markers = cv2.watershed(img, markers)
    img[markers == -1] = [255,0,0]
    
    cv2.imshow('Watershed', img)
    cv2.waitKey(0)

import cv2
import numpy as np


def preprocess_image(image_path):
    """图像预处理：转为灰度图并二值化"""
    img = cv2.imread(image_path)
    if img is None:
        print("无法加载图像，请检查文件路径")
        return None, None

    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    binary = cv2.adaptiveThreshold(gray, 255,
                                   cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                   cv2.THRESH_BINARY_INV, 11, 2)
    return img, binary


def find_contours_demo(image_path):
    """轮廓检测与绘制演示"""
    original, binary = preprocess_image(image_path)
    if original is None:
        return

    contours, hierarchy = cv2.findContours(binary,
                                           cv2.RETR_TREE,
                                           cv2.CHAIN_APPROX_SIMPLE)

    contour_img = original.copy()
    cv2.drawContours(contour_img, contours, -1, (0, 255, 0), 2)

    cv2.imshow("Original", original)
    cv2.imshow("Binary", binary)
    cv2.imshow("Contours", contour_img)

    analyze_contours(original.copy(), contours)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def analyze_contours(img, contours):
    """轮廓特征分析"""
    filtered_contours = [c for c in contours if cv2.contourArea(c) > 1000]

    for i, cnt in enumerate(filtered_contours):
        area = cv2.contourArea(cnt)
        perimeter = cv2.arcLength(cnt, True)
        x, y, w, h = cv2.boundingRect(cnt)

        rect = cv2.minAreaRect(cnt)
        box = cv2.boxPoints(rect)
        box = np.int32(box)  # 修改这里：np.int0 → np.int32

        (x_c, y_c), radius = cv2.minEnclosingCircle(cnt)

        cv2.drawContours(img, [box], 0, (255, 0, 0), 2)
        cv2.circle(img, (int(x_c), int(y_c)), int(radius), (0, 0, 255), 2)

        epsilon = 0.02 * perimeter
        approx = cv2.approxPolyDP(cnt, epsilon, True)

        vertices = len(approx)
        shape = ""
        if vertices == 3:
            shape = "TRI"
        elif vertices == 4:
            aspect_ratio = w / float(h)
            shape = "SQR" if 0.95 <= aspect_ratio <= 1.05 else "RECT"
        elif vertices > 8:
            shape = "CIRCLE"
        else:
            shape = f"POLY{vertices}"

        M = cv2.moments(cnt)
        if M["m00"] != 0:
            cX = int(M["m10"] / M["m00"])
            cY = int(M["m01"] / M["m00"])
            cv2.putText(img, f"{shape} A:{area:.0f}", (cX - 50, cY),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 0), 2)

    cv2.imshow("Contour Analysis", img)


def main():
    print("OpenCV 轮廓检测演示")
    print("请选择模式:")
    print("1: 图像文件轮廓检测")
    print("2: 实时摄像头轮廓检测")

    choice = input("请输入选项 (1-2): ")

    if choice == '1':
        image_path = input("请输入图像路径(或直接回车使用默认图像): ").strip()
        if not image_path:
            image_path = "image.jpg"  # 确保项目目录下有这个图像文件
        find_contours_demo(image_path)
    elif choice == '2':
        print("实时检测功能需要摄像头支持")
    else:
        print("无效输入")


if __name__ == "__main__":
    main()

import cv2
import numpy as np

# 1. 创建一个空白图像（或读取一张图像）
img = np.zeros((400, 400, 3), dtype=np.uint8)  # 黑色背景

# 2. 在图像上绘制一个矩形和一个圆形（用于生成轮廓）
cv2.rectangle(img, (50, 50), (200, 200), (0, 255, 0), 2)  # 绿色矩形
cv2.circle(img, (300, 150), 80, (0, 0, 255), 2)  # 红色圆形

# 3. 转换为灰度图并二值化（便于 findContours 处理）
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_, binary = cv2.threshold(gray, 1, 255, cv2.THRESH_BINARY)

# 4. 查找轮廓
contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# 5. 计算每个轮廓的面积和周长，并绘制结果
for i, contour in enumerate(contours):
    # 计算面积
    area = cv2.contourArea(contour)
    # 计算周长（closed=True 表示闭合轮廓）
    perimeter = cv2.arcLength(contour, closed=True)

    # 绘制轮廓（蓝色）
    cv2.drawContours(img, [contour], -1, (255, 0, 0), 2)

    # 在轮廓中心显示面积和周长
    M = cv2.moments(contour)
    if M["m00"] != 0:
        cx = int(M["m10"] / M["m00"])
        cy = int(M["m01"] / M["m00"])
        cv2.putText(img, f"Area: {area:.1f}", (cx - 50, cy - 20), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
        cv2.putText(img, f"Perimeter: {perimeter:.1f}", (cx - 50, cy + 20), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)

# 6. 显示结果
cv2.imshow("Contours with Area and Perimeter", img)
cv2.waitKey(0)
cv2.destroyAllWindows()