CV-OpenCV图像处理

Carrie_Lei

已于 2024-09-10 20:26:37 修改

阅读量642

点赞数 5

分类专栏： CV 文章标签： opencv 图像处理计算机视觉

于 2024-09-10 17:51:53 首次发布

本文链接：https://blog.csdn.net/finly4599/article/details/142105204

版权

CV 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

OpenCV 是一个功能强大的计算机视觉库，支持各种图像处理任务。以下是一些常见的 OpenCV 图像操作的代码示例，涵盖读取、显示、调整大小、裁剪、旋转、灰度化等操作。

1. 读取与显示图像

import cv2

# 读取图像
image = cv2.imread('image.jpg')

# 显示图像
cv2.imshow('Image', image)

# 等待用户按下任意键
cv2.waitKey(0)

# 关闭所有窗口
cv2.destroyAllWindows()

2. 保存图像

# 保存图像
cv2.imwrite('output.jpg', image)

3. 调整图像大小

# 调整图像大小
resized_image = cv2.resize(image, (300, 300))

# 显示调整后的图像
cv2.imshow('Resized Image', resized_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

4. 裁剪图像

# 裁剪图像（y1:y2, x1:x2）
cropped_image = image[50:200, 100:300]

# 显示裁剪后的图像
cv2.imshow('Cropped Image', cropped_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

5. 旋转图像

# 获取图像中心
(h, w) = image.shape[:2]
center = (w // 2, h // 2)

# 定义旋转矩阵，旋转角度为45度，缩放比例为1
M = cv2.getRotationMatrix2D(center, 45, 1.0)

# 进行旋转操作
rotated_image = cv2.warpAffine(image, M, (w, h))

# 显示旋转后的图像
cv2.imshow('Rotated Image', rotated_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

6. 图像灰度化

# 转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 显示灰度图像
cv2.imshow('Gray Image', gray_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

7. 图像模糊化

# 使用高斯模糊
blurred_image = cv2.GaussianBlur(image, (15, 15), 0)

# 显示模糊后的图像
cv2.imshow('Blurred Image', blurred_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

8. 绘制图形（矩形、圆、线、文本）

# 画矩形 (图像，起始点，终点，颜色，线条粗细)
cv2.rectangle(image, (50, 50), (200, 200), (0, 255, 0), 2)

# 画圆 (图像，圆心，半径，颜色，线条粗细)
cv2.circle(image, (300, 300), 50, (255, 0, 0), 3)

# 画线 (图像，起点，终点，颜色，线条粗细)
cv2.line(image, (100, 100), (400, 400), (0, 0, 255), 5)

# 写文本 (图像，文本，起始点，字体，字体大小，颜色，线条粗细)
cv2.putText(image, 'Hello OpenCV', (100, 400), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# 显示绘制后的图像
cv2.imshow('Shapes', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

9. 图像边缘检测

# 边缘检测 (Canny算法)
edges = cv2.Canny(image, 100, 200)

# 显示边缘检测后的图像
cv2.imshow('Edges', edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

10. 颜色通道分离与合并

# 分离图像的颜色通道
B, G, R = cv2.split(image)

# 显示单个颜色通道
cv2.imshow('Blue Channel', B)
cv2.imshow('Green Channel', G)
cv2.imshow('Red Channel', R)

# 合并颜色通道
merged_image = cv2.merge([B, G, R])

cv2.imshow('Merged Image', merged_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

11. 灰度直方图均衡化

import cv2
import matplotlib.pyplot as plt

# 读取图像并转换为灰度图像
image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 应用直方图均衡化
equalized_image = cv2.equalizeHist(image)

# 显示原始图像和均衡化后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')
plt.axis('off')

# 显示均衡化后的图像
plt.subplot(1, 2, 2)
plt.title('Equalized Image')
plt.imshow(equalized_image, cmap='gray')
plt.axis('off')

plt.show()

12. 彩色亮度直方图均衡化

在 HSV 色彩空间中均衡化亮度通道
将图像从 BGR 转换到 HSV 色彩空间。
对亮度通道（V 通道）进行直方图均衡化。
将图像从 HSV 转换回 BGR 色彩空间。

import cv2
import matplotlib.pyplot as plt

# 读取彩色图像
image = cv2.imread('color_image.jpg')

# 转换为 HSV 色彩空间
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# 提取 V (亮度) 通道
v_channel = hsv_image[:, :, 2]

# 对 V 通道进行直方图均衡化
equalized_v_channel = cv2.equalizeHist(v_channel)

# 替换 HSV 图像中的 V 通道
hsv_image[:, :, 2] = equalized_v_channel

# 转换回 BGR 色彩空间
equalized_image = cv2.cvtColor(hsv_image, cv2.COLOR_HSV2BGR)

# 显示原始图像和均衡化后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# 显示均衡化后的图像
plt.subplot(1, 2, 2)
plt.title('Equalized Image')
plt.imshow(cv2.cvtColor(equalized_image, cv2.COLOR_BGR2

13. 色彩提取

基于 HSV 色彩空间的色彩提取
HSV 色彩空间将颜色信息分为色调（Hue）、饱和度（Saturation）和亮度（Value），可以更容易地定义颜色范围进行提取。

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

# 读取图像并转换为 HSV 色彩空间
image = cv2.imread('color_image.jpg')
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# 定义颜色范围（示例：提取红色）
lower_bound = np.array([0, 50, 50])
upper_bound = np.array([10, 255, 255])
mask = cv2.inRange(hsv_image, lower_bound, upper_bound)

# 进行颜色提取
extracted_color = cv2.bitwise_and(image, image, mask=mask)

# 显示结果
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# 显示提取的颜色
plt.subplot(1, 2, 2)
plt.title('Extracted Color')
plt.imshow(cv2.cvtColor(extracted_color, cv2.COLOR_BGR2RGB))
plt.axis('off')

plt.show()

13. 二值化与反二值化

二值化和反二值化是图像处理中的两个基本操作，用于将图像转换为二值图像（只有黑白两个颜色）。这些操作常用于图像分割、特征提取和前景/背景分离。
二值化（Thresholding）是将灰度图像转换为二值图像的过程。通过设定一个阈值，将像素值分为两类：高于阈值的像素设为白色（255），低于阈值的像素设为黑色（0）。

import cv2
import matplotlib.pyplot as plt

# 读取图像并转换为灰度图像
image = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 定义阈值
threshold_value = 128

# 应用二值化
_, binary_image = cv2.threshold(image, threshold_value, 255, cv2.THRESH_BINARY)

# 显示原始图像和二值化后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(image, cmap='gray')
plt.axis('off')

# 显示二值化后的图像
plt.subplot(1, 2, 2)
plt.title('Binary Image')
plt.imshow(binary_image, cmap='gray')
plt.axis('off')

plt.show()

13. 图像翻转

图像翻转是一种常见的图像处理操作，可以将图像按水平、垂直或对角线翻转。

水平翻转
水平翻转将图像沿垂直轴翻转，左侧变为右侧，右侧变为左侧。

import cv2
import matplotlib.pyplot as plt

# 读取图像
image = cv2.imread('image.jpg')

# 水平翻转图像
flipped_horizontal = cv2.flip(image, 1)

# 显示原始图像和水平翻转后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# 显示水平翻转后的图像
plt.subplot(1, 2, 2)
plt.title('Flipped Horizontally')
plt.imshow(cv2.cvtColor(flipped_horizontal, cv2.COLOR_BGR2RGB))
plt.axis('off')

plt.show()

垂直翻转
垂直翻转将图像沿水平轴翻转，上侧变为下侧，下侧变为上侧。

import cv2
import matplotlib.pyplot as plt

# 读取图像
image = cv2.imread('image.jpg')

# 垂直翻转图像
flipped_vertical = cv2.flip(image, 0)

# 显示原始图像和垂直翻转后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# 显示垂直翻转后的图像
plt.subplot(1, 2, 2)
plt.title('Flipped Vertically')
plt.imshow(cv2.cvtColor(flipped_vertical, cv2.COLOR_BGR2RGB))
plt.axis('off')

plt.show()

水平和垂直翻转
同时进行水平和垂直翻转，相当于对图像进行180度旋转。

import cv2
import matplotlib.pyplot as plt

# 读取图像
image = cv2.imread('image.jpg')

# 水平和垂直翻转图像
flipped_both = cv2.flip(image, -1)

# 显示原始图像和水平垂直翻转后的图像
plt.figure(figsize=(10, 5))

# 显示原始图像
plt.subplot(1, 2, 1)
plt.title('Original Image')
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.axis('off')

# 显示水平垂直翻转后的图像
plt.subplot(1, 2, 2)
plt.title('Flipped Horizontally and Vertically')
plt.imshow(cv2.cvtColor(flipped_both, cv2.COLOR_BGR2RGB))
plt.axis('off')

plt.show()

14. 图像仿射变换

'''
仿射变换:平移和旋转
'''

import cv2
import numpy as np


def translate(img, tx, ty):
    h, w = img.shape[:2]
    M = np.float32([[1, 0, tx],
                    [0, 1, ty]])
    res = cv2.warpAffine(img,
                         M,
                   (w+tx,h+ty),
                         borderValue=(255,255,255))
    return res

def rotate(img, angle, center=None):
    h,w = img.shape[:2]
    if center is None:
        center = (w//2, h//2)
    # 获取旋转矩阵
    M = cv2.getRotationMatrix2D(center, angle, 1)
    res = cv2.warpAffine(img,
                   M,
                   (w, h))
    return res

if __name__ == '__main__':
    img = cv2.imread('../data/lena.jpg')
    cv2.imshow('img', img)

    translated = translate(img, 50, 20)
    cv2.imshow('translated', translated)

    rotate = rotate(img, 45)
    cv2.imshow('rotate', rotate)

    cv2.waitKey()
    cv2.destroyAllWindows()

15. 图像缩放

'''
图像的缩放
'''

import cv2

img = cv2.imread('../data/Linus.png')
cv2.imshow('Linus', img)

#缩小
h, w = img.shape[:2]

reduce = cv2.resize(img, (w//2, h//2))
cv2.imshow('reduce', reduce)

#放大#最邻近插值法
enlarge = cv2.resize(img, (w*2, h*2), interpolation=cv2.INTER_NEAREST)
cv2.imshow('enlarge', enlarge)
#放大##双线性插值法
linear = cv2.resize(img, (w*2, h*2), interpolation=cv2.INTER_LINEAR)
cv2.imshow('linear', linear)

cv2.waitKey()
cv2.destroyAllWindows()

代码解释

读取图像：
- 使用 cv2.imread() 读取图像文件。
计算新尺寸：
- 获取原始图像的宽度和高度。
- 根据缩放比例（scale_percent）计算新的尺寸。
图像缩放：
- 使用 cv2.resize() 函数进行图像缩放。
- dim 变量指定了缩放后的图像尺寸。
- interpolation 参数指定了插值方法。常见的插值方法包括：
  - cv2.INTER_LINEAR：线性插值，适用于图像缩小。
  - cv2.INTER_NEAREST：最近邻插值，速度较快，但可能会出现锯齿。
  - cv2.INTER_CUBIC：立方插值，适用于图像放大，效果较好但速度较慢。
  - cv2.INTER_LANCZOS4：Lanczos插值，适用于图像放大，效果更好但计算开销较大。
显示图像：
- 使用 Matplotlib 显示原始图像和缩放后的图像。

缩放示例

缩小图像：
- 通过调整 scale_percent 的值小于 100% 来缩小图像。
放大图像：
- 通过调整 scale_percent 的值大于 100% 来放大图像。

注意事项

插值方法：选择适当的插值方法可以影响缩放图像的质量。
性能：图像的缩放可能会影响处理性能，特别是在处理大图像时。
尺寸限制：在缩放图像时，确保新的尺寸在合理范围内，以避免过度失真或性能问题。

这些基本的操作可以帮助你进行图像的大小调整，以满足不同的应用需求。

16. 图像裁剪

'''
图像的裁剪:随机裁剪,中心裁剪
'''
import cv2
import numpy as np


#随机裁剪
def random_crop(img, cw, ch):
    h, w = img.shape[:2]
    start_x = np.random.randint(0, w-cw)
    start_y = np.random.randint(0, h-ch)
    return img[start_y:start_y+ch, start_x:start_x+cw]

def center_crop(img, cw, ch):
    h, w = img.shape[:2]
    start_x = (w-cw)//2
    start_y = (h-ch)//2
    return img[start_y:start_y+ch, start_x:start_x+cw]

if __name__ == '__main__':
    img = cv2.imread('../data/banana_1.png')
    cv2.imshow('img', img)
    #随机裁剪
    random_res = random_crop(img, 300, 300)
    cv2.imshow('random_res', random_res)
    #中心裁剪
    center_res = center_crop(img, 300, 300)
    cv2.imshow('center_res', center_res)

    cv2.waitKey()
    cv2.destroyAllWindows()

17. 图像相加

'''
图像的相加：对应位置像素值对应相加(两张相加的图像shape要一致)
'''

import cv2

img = cv2.imread('../data/lena.jpg', 0)
cv2.imshow('lena', img)
img2 = cv2.imread('../data/lily_square.png', 0)
cv2.imshow('Lily', img2)
#相加
img3 = cv2.add(img, img2)
cv2.imshow('add', img3)
#按照权重进行相加
img4 = cv2.addWeighted(img, 0.5, img2, 0.5, 0)
cv2.imshow('addWeighted', img4)

cv2.waitKey()
cv2.destroyAllWindows()

18. 图像相减

# 图像相减运算示例
import cv2

a = cv2.imread("../data/3.png", 0)
b = cv2.imread("../data/4.png", 0)

dst = cv2.subtract(a, b)  # 两幅图像相减，是求出图像的差异

cv2.imshow("a", a)
cv2.imshow("b", b)
cv2.imshow("dst1", dst)

cv2.waitKey()
cv2.destroyAllWindows()

18. 透视变换

'''
透视变换
'''

import cv2
import numpy as np

img = cv2.imread('../data/pers.png', 0)
cv2.imshow('img', img)

h,w = img.shape[:2]

# 图像的四个顶点坐标
pts1 = np.float32([[58,2],[167,9],[8,196],[126,196]])
pts2 = np.float32([[16,2],[167,8],[8,196],[169,196]])

# 获取变换矩阵
M = cv2.getPerspectiveTransform(pts1, pts2)
#透视变换
res = cv2.warpPerspective(img, M, (w, h))
cv2.imshow('res', res)

cv2.waitKey()
cv2.destroyAllWindows()

19. 图像腐蚀

# 图像腐蚀
import cv2
import numpy as np

# 读取原始图像
im = cv2.imread("../data/5.png")
cv2.imshow("im", im)

# 腐蚀
kernel = np.ones((3, 3), np.uint8) # 用于腐蚀计算的核
erosion = cv2.erode(im, # 原始图像
                    kernel,  # 腐蚀核
                    iterations=3) # 迭代次数
cv2.imshow("erosion", erosion)

cv2.waitKey()
cv2.destroyAllWindows()

20. 图像膨胀

# 图像膨胀
import cv2
import numpy as np

# 读取原始图像
im = cv2.imread("../data/6.png")
cv2.imshow("im", im)

# 膨胀
kernel = np.ones((3, 3), np.uint8)  # 用于膨胀计算的核
dilation = cv2.dilate(im,  # 原始图像
                      kernel,  # 膨胀核
                      iterations=5)  # 迭代次数
cv2.imshow("dilation", dilation)

cv2.waitKey()
cv2.destroyAllWindows()

21. 图像开运算

'''
开运算，先腐蚀再膨胀
'''

import cv2
import numpy as np

img = cv2.imread('./data/5.png',0)
cv2.imshow('img',img)

kernel = np.ones((3,3),np.uint8)
open = cv2.morphologyEx(img,cv2.MORPH_OPEN,kernel,
                        iterations=3)
cv2.imshow('open',open)

cv2.waitKey()
cv2.destroyAllWindows()

22. 图像闭运算

'''
闭运算：先膨胀，在腐蚀
'''

import cv2
import numpy as np

img = cv2.imread('./data/9.png',0)
cv2.imshow('img',img)

kernel = np.ones((3,3),np.uint8)
close = cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel,
                        iterations=10)
cv2.imshow('close',close)

cv2.waitKey()
cv2.destroyAllWindows()

23. 形态学梯度

'''
形态学梯度
'''
import cv2
import numpy as np

img = cv2.imread('./data/6.png',0)
cv2.imshow('img',img)

kernel = np.ones((2,2),np.uint8)
gradient = cv2.morphologyEx(img,cv2.MORPH_GRADIENT,kernel,
                            iterations=1)
cv2.imshow('gradient',gradient)


cv2.waitKey()
cv2.destroyAllWindows()

24. 模糊处理

'''
图像的模糊(平滑)
'''

import cv2
import numpy as np

img = cv2.imread('../data/salt.jpg', 1)
cv2.imshow('img', img)

#均值滤波
blured = cv2.blur(img, (13, 13))
cv2.imshow('blured', blured)

#高斯滤波
gaussianBlur = cv2.GaussianBlur(img, (13, 13), 0)
cv2.imshow('gaussianBlur', gaussianBlur)

#中值滤波
medianBlur = cv2.medianBlur(img, 5)
cv2.imshow('medianBlur', medianBlur)

#自定义卷积核实现均值滤波
kernel = np.ones((13, 13), np.float32)/169 # 除以权重值之和
dst = cv2.filter2D(img, -1, kernel)
cv2.imshow('dst', dst)

cv2.waitKey()
cv2.destroyAllWindows()

25. 图像锐化处理

'''
锐化:增大像素与像素之间的差异
'''

import cv2
import numpy as np

img = cv2.imread('../data/lena.jpg', 1)
cv2.imshow('img', img)

#自定义锐化算子卷积核
kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]], dtype='float32')
sharpen = cv2.filter2D(img, -1, kernel)
cv2.imshow('sharpen', sharpen)

cv2.waitKey()
cv2.destroyAllWindows()

26. 边沿检测

'''
边沿检测
'''

import cv2
import numpy as np

img = cv2.imread('../data/lena.jpg', 1)
cv2.imshow('img', img)

# Sobel
sobel = cv2.Sobel(img, cv2.CV_64F, 1, 1, ksize=5)
cv2.imshow('sobel', sobel)

#Laplacian
laplacian = cv2.Laplacian(img, cv2.CV_64F)
cv2.imshow('laplacian', laplacian)

# Canny
canny = cv2.Canny(img, 100, 200)
cv2.imshow('canny', canny)

cv2.waitKey()
cv2.destroyAllWindows()

'''
针对于paper.jpg中的图像，将纸的目标物体(轮廓)变成白色，背景变为黑色
'''
import cv2
import numpy as np

img = cv2.imread('../data/paper.jpg', 1)
cv2.imshow('img', img)

##灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow('gray', gray)

#二值化
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('thresh', thresh)

#高斯模糊
img = cv2.GaussianBlur(img, (5, 5), 0)

#canny
img = cv2.Canny(img, 100, 200)
cv2.imshow('canny', img)

cv2.waitKey()
cv2.destroyAllWindows()

27. 查找图像轮廓

'''
查找并绘制轮廓
'''

import cv2
import numpy as np

img = cv2.imread('../data/3.png', 1)
cv2.imshow('img', img)

# 灰度化
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow('gray', gray)

ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('binary', binary)

# 查找轮廓
contours, hierarchy = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
print(len(contours))

for i in contours:
    print(i.shape)

print(hierarchy)

res = cv2.drawContours(img, contours, -1, (0, 0, 255), 2)
cv2.imshow('res', res)

cv2.waitKey()
cv2.destroyAllWindows()

28. 绘制矩形包围框

'''
拟合轮廓的矩形
'''

import cv2
import numpy as np

img = cv2.imread('../data/cloud.png')
cv2.imshow('img',img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

# print(len(contours))

x, y, w, h = cv2.boundingRect(contours[0])
points = [np.array([[[x, y]], [[x, y+h]], [[x+w, y+h]], [[x+w, y]]])]
cv2.drawContours(img, points, 0, (0, 0, 255), 2)
cv2.imshow('res', img)

cv2.waitKey()
cv2.destroyAllWindows()

29. 绘制圆形包围圈

'''
拟合轮廓的圆形包围框
'''

import cv2
import numpy as np

img = cv2.imread('../data/cloud.png')
cv2.imshow('img',img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

# print(len(contours))

#拟合圆形包围框
center, radius = cv2.minEnclosingCircle(contours[0])
#将圆心和半径转成整数
center = int(center[0]), int(center[1])
radius = int(radius)
cv2.circle(img, center, radius, (0, 255, 0), 2)
cv2.imshow('res',img)

cv2.waitKey()
cv2.destroyAllWindows()

29. 绘制最佳拟合椭圆

'''
拟合轮廓的椭圆
'''

import cv2
import numpy as np

img = cv2.imread('../data/cloud.png')
cv2.imshow('img',img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

#拟合椭圆
ellipse = cv2.fitEllipse(contours[0])
cv2.ellipse(img, ellipse, color = (0,255,0), thickness=2)
cv2.imshow('res',img)

cv2.waitKey()
cv2.destroyAllWindows()

30. 逼近多边形

'''
拟合轮廓的多边形
'''

import cv2
import numpy as np

img = cv2.imread('../data/cloud.png')
cv2.imshow('img',img)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

#拟合轮廓的多边形
adp1 = img.copy()
eps = 0.001 * cv2.arcLength(contours[0], True)
approx = cv2.approxPolyDP(contours[0], eps, True)
cv2.drawContours(adp1, [approx], 0, (0, 0, 255), 2)
cv2.imshow('adp1', adp1)

adp2 = img.copy()
eps = 0.01 * cv2.arcLength(contours[0], True)
approx = cv2.approxPolyDP(contours[0], eps, True)
cv2.drawContours(adp2, [approx], 0, (0, 0, 255), 2)
cv2.imshow('adp2', adp2)

cv2.waitKey()
cv2.destroyAllWindows()