opencv简单小实战

最新推荐文章于 2025-03-14 11:13:09 发布

知识鱼丸

最新推荐文章于 2025-03-14 11:13:09 发布

阅读量908

点赞数 14

分类专栏： opencv 文章标签： opencv 人工智能计算机视觉

本文链接：https://blog.youkuaiyun.com/bananapai/article/details/144563858

版权

opencv 专栏收录该内容

6 篇文章

订阅专栏

1：读取一张彩色图像并将其转换为灰度图。

import cv2
 
# 读取名为 '1.png'的图片文件
img = cv2.imread('1.png')
 
# 将原图像从 BGR（Blue Green Red）颜色空间转换到灰度空间，存放在 img_gray 中
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
 
# 使用 imshow函数 显示灰度图片
cv2.imshow('img_gray', img_gray)
cv2.waitKey(0)

2：二值化与形态学操作‌

编写程序，读取一张彩色图像，将其转换为灰度图，然后进行二值化处理。

接着，对二值化后的图像执行腐蚀和膨胀操作，并显示处理前后的图像

import cv2


img=cv2.imread('./cat.png')

img_grey=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
img_binary=cv2.adaptiveThreshold(img_grey,#tu
                                          255,#zuidazhi
                                          cv2.ADAPTIVE_THRESH_MEAN_C,#adaptivevalue
                                          cv2.THRESH_BINARY,#binarytype
                                          215,#核的size
                                           8) #changshu


kernel=cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3))

img_erode=cv2.erode(img_binary,kernel)
img_dilate=cv2.dilate(img_erode,kernel)

cv2.imshow('0',img)
cv2.imshow('1',img_binary)
cv2.imshow('2',img_erode)
cv2.imshow('3',img_dilate)
cv2.waitKey(0)

3：图像变换与颜色识别‌

编写程序，读取一张彩色图像，执行以下操作：

将图像缩放至指定大小（例如，宽度和高度都缩小为原来的一半）。
对缩放后的图像应用仿射变换，实现图像的旋转（例如，旋转45度）。
将图像从BGR颜色空间转换为HSV颜色空间，并提取出特定的颜色范围（例如，提取黄色区域）。

import cv2
import numpy as np

# 读取名为 'cat.png' 的图片
img = cv2.imread('./cat.png')

# 将图像的宽度缩小为原来的0.7倍，高度缩小为原来的0.5倍
img1 = cv2.resize(img, (0, 0), fx=0.7, fy=0.5)

# 获取一个将图像逆时针旋转45度，并且缩小0.5倍的旋转矩阵
m = cv2.getRotationMatrix2D((img.shape[1] / 2, img.shape[0] / 2), 45, 0.5)

# 对图像进行仿射变换（此处为旋转变换）并进行边界填充
img1 = cv2.warpAffine(img, m, (img1.shape[1], img1.shape[0]), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_REFLECT_101)

# 将BGR图像转换为HSV图像
img_hsv = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV)

# 为HSV空间的黄色设定阈值
hsv_min = np.array([35, 43, 46])
hsv_max = np.array([77, 255, 255])

# 对HSV空间进行阈值过滤，得到黄色的掩码
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)

# 遍历所有像素，如果该像素在黄色掩码下的值为255，即为黄色区域，将该像素的颜色更改为R=255, G=35, B=79的颜色
for i in range(img_mask_y.shape[0]):
    for j in range(img_mask_y.shape[1]):
        if img_mask_y[i, j] == 255:
            img1[i, j, :] = (255, 35, 79)

# 展示处理后的图片
cv2.imshow('img1', img1)
cv2.waitKey(0)

4、图像矫正

编写程序，读取一张彩色图像，执行以下操作

找到原图和目标图的四个点，获取透视变换矩阵
对图像应用透视变换，实现油画区域的矫正

import cv2
import numpy as np
 
# 读取名为 '13.png' 的图片文件
img = cv2.imread('13.png')
 
# 定义透视变换前后的四个边界点
p1 = np.array([[173, 141], [623, 34], [85, 497], [656, 555]], dtype=np.float32)
 
# 定义透视变换后左上、右上、左下和右下四个角的位置
p2 = np.array([[0, 0], [img.shape[1], 0], [0, img.shape[0]], [img.shape[1], img.shape[0]]], dtype=np.float32)
 
# 通过 getPerspectiveTransform 函数获取透视变换矩阵
M = cv2.getPerspectiveTransform(p1, p2)
 
# 使用 warpPerspective 函数对原图进行透视变换
img_warp = cv2.warpPerspective(img, M, (img.shape[1], img.shape[0]))
 
# 显示原图和透视变换后的图像
cv2.imshow("img", img)
cv2.imshow('img_warp', img_warp)
cv2.waitKey(0)

5、轮廓绘制

请编写一段Python代码，使用OpenCV库对一张图像进行以下处理：

将图像转换为灰度图。
使用滤波器平滑图像
使用Canny边缘检测算法检测图像边缘
在检测到的边缘图像上绘制轮廓，轮廓颜色为红色，厚度为2。

import cv2
import numpy as np

#输入
img=cv2.imread('./cat.png')

#hsv
img_hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)

#设定颜色范围
hsv_min_green=np.array([35,43,46])
hsv_max_green=np.array([77,255,255])
img_mask_green=cv2.inRange(img_hsv,hsv_min_green,hsv_max_green)

#滤波
img_m_blur = cv2.medianBlur(img_mask_green,7)

#腐蚀膨胀
kernel=cv2.getStructuringElement(cv2.MORPH_CROSS,(3,3))
img_erode=cv2.erode(img_m_blur,kernel)
img_dilate=cv2.dilate(img_erode,kernel)

#寻找轮廓
contours,hierarchy=cv2.findContours(img_dilate,     #二值化的图
                                    cv2.RETR_LIST,  #查询轮廓方式
                                    cv2.CHAIN_APPROX_SIMPLE)
#寻找轮廓
img_copy=img.copy()
for i in contours:
    if cv2.contourArea(i)<=200:
        continue
    cv2.drawContours(img_copy,[i],0,(0,0,255),3)

if __name__=='__main__':
    cv2.imshow('0',img_copy)
    cv2.waitKey(0)

6，交通信号灯识别‌

你正在开发一个自动驾驶系统，需要识别交通信号灯的颜色（红、黄、绿）。请设计一个简化的流程，说明如何使用OpenCV来识别交通信号灯的颜色。

思路分析‌：

读取包含交通信号灯的图像。
转换图像到HSV颜色空间。
分别为红、黄、绿三种颜色定义HSV范围，并创建三个掩膜。
对每个掩膜进行轮廓检测，识别出可能的信号灯区域。

 
import cv2
import numpy as np
 
# 读取图片 '1.png'
img = cv2.imread('1.png')
 
# 将原图片从BGR颜色空间转换为HSV颜色空间
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
 
# 按照HSV颜色空间中黄色的范围创建掩膜
hsv_min = np.array([26, 43, 46])
hsv_max = np.array([34, 255, 255])
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)
 
# 按照HSV颜色空间中绿色的范围创建掩膜
hsv_min = np.array([35, 43, 46])
hsv_max = np.array([77, 255, 255])
img_mask_green = cv2.inRange(img_hsv, hsv_min, hsv_max)
 
# 按照HSV颜色空间中红色的范围创建两个掩膜，然后合并
hsv_min1 = np.array([0, 43, 46])
hsv_max1 = np.array([10, 255, 255])
hsv_min2 = np.array([156, 43, 46])
hsv_max2 = np.array([180, 255, 255])
img_mask_r1 = cv2.inRange(img_hsv, hsv_min1, hsv_max1)
img_mask_r2 = cv2.inRange(img_hsv, hsv_min2, hsv_max2)
img_mask_r = cv2.bitwise_or(img_mask_r2, img_mask_r1)
 
# 将黄色、绿色和红色的掩膜进行或运算，使这三个颜色区域的掩膜合并
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_y)
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_green)
 
# 在原图上使用掩膜，让其他颜色的区域为黑色，只保留红、黄、绿三色
img_mask_toil = cv2.bitwise_and(img, img, mask=img_mask_r)
 
# 使用高斯锐化处理掩膜后的图像，把图像转换为灰度，然后进行阈值处理，得到二值图
img_blur = cv2.GaussianBlur(img_mask_toil, (5, 5), 0)
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)
_, th = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
# 查找二值图的轮廓，得到轮廓列表
contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
img_copy = img.copy()
 
# 遍历轮廓列表，忽略掉面积太小的轮廓，对每个轮廓在原图上绘制矩形框
for i in contours:
    area = cv2.contourArea(i)
    if area < 2000:
        continue
    (x, y), d = cv2.minEnclosingCircle(i)
    center = (int(x), int(y))
    radius = int(d)
    cv2.circle(img, center, radius, (255, 0, 255), 2)
 
# 在复制的图片上绘制找到的所有轮廓
cv2.drawContours(img_copy, contours, -1, (0, 255, 0), 2)
 
# 显示处理后的图片
cv2.imshow('img_hsv_r', img)
cv2.waitKey(0)

7、颜色识别

在一家生产彩色玩具的工厂中，需要检测产品是否按照正确的颜色进行生产。请设计一个使用OpenCV的自动化检测系统，该系统能够识别并报告不符合颜色标准的产品。

‌思路分析‌：

设定产品的标准颜色范围（HSV值）。
使用摄像头或图像文件获取待检测产品的图像。
转换图像到HSV颜色空间。
为每种标准颜色创建掩膜，并与产品图像进行比对。
识别出颜色不符合标准的产品，并记录或报告。

import cv2
import numpy as np
 
# 读取产品图片 'duck.png'
img = cv2.imread('duck.png')
 
# 将原图片从BGR颜色空间转换为HSV颜色空间
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
 
# 按照HSV颜色空间中黄色的范围创建掩膜
hsv_min = np.array([26, 43, 46])
hsv_max = np.array([34, 255, 255])
img_mask_y = cv2.inRange(img_hsv, hsv_min, hsv_max)
 
# 按照HSV颜色空间中白色的范围创建掩膜
hsv_min = np.array([0, 0, 221])
hsv_max = np.array([180, 30, 255])
img_mask_w = cv2.inRange(img_hsv, hsv_min, hsv_max)
 
# 按照HSV颜色空间中橙色的范围创建掩膜
hsv_min = np.array([11, 43, 46])
hsv_max = np.array([25, 255, 255])
img_mask_orange = cv2.inRange(img_hsv, hsv_min, hsv_max)
 
# 将黄色和白色的掩膜进行或运算，使这两个颜色区域的掩膜合并
img_mask_r = cv2.bitwise_or(img_mask_w, img_mask_y)
img_mask_r = cv2.bitwise_or(img_mask_r, img_mask_orange)
# 使用bitwise_not函数，得到的结果中，黄色和白色区域为黑色，其他颜色区域为白色
img_mask_and = cv2.bitwise_not(img_mask_r)
 
# 在原图和掩膜上进行"与"操作，保留其他颜色区域，黄色和白色区域黑色
img_toil = cv2.bitwise_and(img, img, mask=img_mask_and)
# 使用高斯锐化处理掩膜后的图像，把图像转换为灰度，然后进行阈值处理，得到二值图
img_blur = cv2.GaussianBlur(img_toil, (5, 5), 0)
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)
 
_, th = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
# 基于色块区域提取轮廓
contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
# 在原始图像上绘制轮廓
for contour in contours:
    # 可以通过设置面积阈值来忽略小颜色块
    if cv2.contourArea(contour) > 4000:
        cv2.drawContours(img, [contour], -1, (0, 0, 255), 2)
 
# 显示处理后的图片
cv2.imshow('Detected Objects', img)
cv2.waitKey(0)

8、图像预处理与特征提取‌

将图像转换为灰度图
对灰度图进行二值化处理
使用形态学变换去除噪声【开运算】
检测图像中的边缘
查找并绘制图像中的轮廓
逐一遍历轮廓，输出所有四边形的周长和面积

# 引入cv2和matplotlib.pyplot模块
import cv2
import matplotlib.pyplot as plt
 
# 使用cv2读取图像
img = cv2.imread('4.png')
 
# 对图像进行高斯模糊操作，使用3*3的核，标准差为1
img_blur = cv2.GaussianBlur(img, (3, 3), 1)
 
# 把模糊后的图像从BGR变为灰度图
img_gray = cv2.cvtColor(img_blur, cv2.COLOR_BGR2GRAY)
 
# 使用OSTU进行图像二值化，阈值设为127，二值化后小于阈值的部分设为255，大于设为0，反向输出
_, img_binary = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
 
# 使用cv2找到二值化图像中的所有轮廓
contours, _ = cv2.findContours(img_binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
# 创建一个原图的副本
img_copy = img.copy()
 
# 遍历所有找到的轮廓
for i in contours:
    # 计算轮廓的矩
    m = cv2.moments(i)
 
    # 如果轮廓的面积（零阶矩）等于0，则继续下一轮循环
    if int(m['m00']) == 0:
        continue
 
    # 计算轮廓的周长
    arc_len = cv2.arcLength(i, True)
 
    # 使用Ramer-Douglas-Peucker算法找到轮廓的近似多边形
    approx = cv2.approxPolyDP(i, float(0.04) * arc_len, True)
 
    # 画出轮廓
    cv2.drawContours(img_copy, contours, -1, (0, 0, 0), 2)
 
    # 计算轮廓的重心
    cx = int(m['m10'] / m['m00'])
    cy = int(m['m01'] / m['m00'])
 
    # 判断多边形的形状
    if len(approx) == 3:
        square = 'triangle'
    elif len(approx) == 4:
        x, y, w, h = cv2.boundingRect(approx)
        ratio = w / h
        if ratio > 0.95 and ratio < 1.05:
            square = 'square'
        else:
            square = 'rectangle'
    elif len(approx) == 5:
        square = 'pentagon'
    else:
        square = 'circle'
 
    # 用文本标记出各个面积
    cv2.putText(img_copy, str(m['m00']), (cx, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
 
# 画出所有的轮廓
cv2.drawContours(img_copy, contours, -1, (0, 255, 0), 2)
 
# 显示处理后的图像
cv2.imshow('img', img_copy)
cv2.waitKey(0)

9、车牌识别系统

首先需要从图像中识别出车牌区域。请描述并编写代码实现以下步骤：

读取一张包含车牌的图像。
将图像转换为灰度图以简化处理。
使用高斯滤波器平滑图像，减少噪声干扰。
应用Canny边缘检测算法检测图像中的边缘。
查找图像中的轮廓。
逐一遍历轮廓。
设定一个面积双阈值，只保留面积在该阈值的轮廓。
计算这些轮廓的长宽比，长宽比ratio在2到5.5之间的，在原图上用矩形框标出，这些轮廓可能是车牌的候选区域。

import cv2
import numpy as np
 
# 1. 读取图像
image = cv2.imread('img.png')  # 请确保路径正确
# 2. 转换为灰度图
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
# 3. 使用高斯滤波器平滑图像
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
 
# 4. 应用Canny边缘检测
edges = cv2.Canny(blurred, 100, 200)
 
# 5. 查找图像中的轮廓
contours, _ = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 
# 6. 遍历轮廓，进行筛选
for contour in contours:
    # 7. 设定面积双阈值，保留较大的轮廓
    if cv2.contourArea(contour) < 1000:  # 可调整这个值来过滤掉较小的轮廓
        continue
 
    # 8. 计算轮廓的矩形边界框
    x, y, w, h = cv2.boundingRect(contour)
 
    # 计算长宽比
    aspect_ratio = w / float(h)
 
    # 设定长宽比的阈值，筛选出符合车牌特征的矩形
    if 2 < aspect_ratio < 5.5:  # 车牌一般是长方形，长宽比通常在这个范围内
        # 画出轮廓
        cv2.drawContours(image, [contour], -1, (0, 255, 0), 3)  # 用绿色绘制轮廓
 
        # 在轮廓周围绘制矩形框
        cv2.rectangle(image, (x, y), (x + w, y + h), (0, 0, 255), 2)  # 用红色矩形框标出车牌区域
 
# 9. 显示结果
cv2.imshow('Car Plate Detection', image)
 
# 按任意键关闭图像窗口
cv2.waitKey(0)
cv2.destroyAllWindows()