学习日志024--opencv中处理轮廓的函数

在计算机视觉（Computer Vision, CV）中，边缘识别是一个至关重要的步骤，它对于多种图像处理和计算机视觉任务都具有重要意义。在OpenCV等计算机视觉库中，提供了多种边缘检测算法（如Sobel算子、Laplacian算子、Canny边缘检测等），这些算法可以有效地识别图像中的边缘信息，为后续的图像处理和分析任务提供有力支持。通过合理地选择和调整算法参数，我们可以获得更好的边缘检测效果，从而提高计算机视觉任务的准确性和效率。

一、梯度处理的sobel算子函数

功能

Sobel算子是一种用于图像处理中边缘检测的算法，主要利用图像像素梯度的方法来计算图像亮度的一阶梯度，从而突出图像中的边缘。它通常用于计算机视觉和图像处理任务中，如物体检测、图像分割等。Sobel 函数通常用于边缘检测、图像分割、特征提取等图像处理任务中。通过计算图像在 x 和 y 方向上的梯度，可以突出图像中的边缘信息，这对于后续的图像分析和处理非常有用。

python 复制代码

@_typing.overload
def Sobel(src: cv2.typing.MatLike,
          ddepth: int,
          dx: int, 
          dy: int, 
          dst: cv2.typing.MatLike | None = ..., 
          ksize: int = ..., 
          scale: float = ...,
          delta: float = ..., 
          borderType: int = ...)\
        -> cv2.typing.MatLike: ...

参数

‌**src (cv2.typing.MatLike)**‌:

输入图像，必须是一个灰度图像或彩色图像的一个通道。

类型：cv2.typing.MatLike，表示兼容 OpenCV 矩阵类型的输入。

‌**ddepth (int)**‌:

输出图像的所需深度。当参数值为 -1 时，输出图像与输入图像具有相同的深度。否则，它可以是 cv2.CV_8U, cv2.CV_16U, cv2.CV_32F 等之一，表示 8 位无符号、16 位无符号或 32 位浮点类型。

‌**dx (int)**‌:

x 方向上的导数阶数。当需要计算 x 方向上的梯度时，将其设置为 1；否则设置为 0.

‌**dy (int)**‌:

y 方向上的导数阶数。当需要计算 y 方向上的梯度时，将其设置为 1；否则设置为 0。

‌**dst (cv2.typing.MatLike | None)**‌:

输出图像，与输入图像具有相同的大小和类型。如果此参数为 None，则函数会创建一个新的输出图像。

类型：cv2.typing.MatLike | None，表示可以是兼容 OpenCV 矩阵类型的输出，或者为 None。

**ksize (int, 默认值为 3)**‌:

Sobel 算子的大小，必须是 1、3、5、7 之一。它表示算子在 x 或 y 方向上使用的像素邻域的大小。

‌**scale (float, 默认值为 1)**‌:

可选的比例因子，用于缩放导数的绝对值。默认情况下，不进行缩放。

‌**delta (float, 默认值为 0)**‌:

可选的增量值，该值会被加到最终的梯度图像中。这可以用于调整结果的亮度或对比度。

**borderType (int, 默认值为 cv2.BORDER_DEFAULT)**‌:

边界模式，用于指定边界外像素的外推方法。常见的边界模式包括 cv2.BORDER_CONSTANT, cv2.BORDER_REFLECT, cv2.BORDER_REPLICATE 等。默认值为 cv2.BORDER_DEFAULT，它通常表示一种合理的默认边界外推方法。

返回值

‌cv2.typing.MatLike ‌:

输出图像，包含了计算得到的梯度信息。如果 dst 参数不为 None，则此输出图像与 dst 参数指向的图像相同；否则，函数会返回一个新的图像。

代码演示

python 复制代码

import cv2
import numpy as np

# 读取一张图
img = cv2.imread('./shudu.png')


# sobel算子

# 水平梯度处理
img_sobel1 = cv2.Sobel(img,-1,0,dy=1,ksize=3)

# 垂直梯度处理
img_sobel2 = cv2.Sobel(img,-1,1,dy=0,ksize=3)

# 进行梯度处理 方法一

cv2.imshow('image',img)

cv2.imshow('img_sobel',img_sobel1)
cv2.imshow('img_sobel2',img_sobel2)
cv2.waitKey(0)

二、梯度处理拉普拉斯算子

Laplacian算子是一种用于图像处理中边缘检测的二阶微分算子。与Sobel算子不同，Laplacian算子通过计算图像像素值的二阶导数来检测边缘，因此它对图像中的噪声更加敏感，但也能更精确地定位边缘。

功能

Laplacian算子函数的主要功能是检测图像中的边缘和纹理变化。它通过计算图像的二阶导数来突出图像中的快速变化区域，这些区域通常对应于边缘或纹理。

python 复制代码

def Laplacian(src: cv2.typing.MatLike,
              ddepth: int, 
              dst: cv2.typing.MatLike | None = ...,
              ksize: int = ..., 
              scale: float = ..., 
              delta: float = ...,
              borderType: int = ...) \
        -> cv2.typing.MatLike: ...

参数

‌**src (cv2.typing.MatLike)**‌:

输入图像，必须是一个灰度图像。

类型：cv2.typing.MatLike，表示兼容 OpenCV 矩阵类型的输入。

‌**ddepth (int)**‌:

输出图像的所需深度。它决定了输出图像的数据类型，如 cv2.CV_8U（8 位无符号）、cv2.CV_16U（16 位无符号）、cv2.CV_32F（32 位浮点）或 cv2.CV_64F（64 位浮点）等。当参数值为 -1 时，输出图像与输入图像具有相同的深度。

‌**dst (cv2.typing.MatLike | None)**‌:

输出图像，与输入图像具有相同的大小和类型（除非 ddepth 指定了不同的深度）。如果此参数为 None，则函数会创建一个新的输出图像。

类型：cv2.typing.MatLike | None，表示可以是兼容 OpenCV 矩阵类型的输出，或者为 None。

‌**ksize (int, 默认值为 1)**‌:

用于计算二阶导数的滤波器的大小。它必须是正奇数，且通常取值为 1、3、5 等。当 ksize=1 时，表示使用标准的 Laplacian 滤波器（即二阶导数滤波器）；当 ksize 大于 1 时，表示使用扩展的 Laplacian 滤波器，这有助于在保持边缘检测精度的同时减少噪声的影响。

‌**scale (float, 默认值为 1)**‌:

可选的比例因子，用于缩放二阶导数的绝对值。默认情况下，不进行缩放。

‌**delta (float, 默认值为 0)**‌:

可选的增量值，该值会被加到最终的梯度图像中。这可以用于调整结果的亮度或对比度。

‌**borderType (int, 默认值为 cv2.BORDER_DEFAULT)**‌:

边界模式，用于指定边界外像素的外推方法。常见的边界模式包括 cv2.BORDER_CONSTANT（常数填充）、cv2.BORDER_REFLECT（反射）、cv2.BORDER_REPLICATE（复制）等。默认值为 cv2.BORDER_DEFAULT，它通常表示一种合理的默认边界外推方法。

返回值

‌cv2.typing.MatLike ‌:

输出图像，包含了计算得到的二阶导数信息（即 Laplacian 结果）。如果 dst 参数不为 None，则此输出图像与 dst 参数指向的图像相同；否则，函数会返回一个新的图像。

代码演示

python 复制代码

import cv2

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

img_lap = cv2.Laplacian(img,-1,ksize=3)



cv2.imshow('image',img)

cv2.imshow('image_lap',img_lap)

cv2.waitKey(0)

三、Canny算子

Canny算子（Canny Edge Detector）是一种多级边缘检测算法，被广泛应用于图像处理中，以获取图像的边缘信息。它以其良好的检测性能和抗噪声能力而著称。下面是Canny算子函数的功能、参数、返回值以及应用。

功能

Canny算子函数的主要功能是检测图像中的边缘，同时尽可能地减少噪声的影响，并精确地定位边缘。它通过一系列的处理步骤，包括高斯滤波、计算梯度、非极大值抑制和双阈值检测，来实现这一目标。

参数

python 复制代码

def Canny(image: cv2.typing.MatLike,
          threshold1: float, 
          threshold2: float,
          edges: cv2.typing.MatLike | None = ..., 
          apertureSize: int = ..., L2gradient: bool = ...) \
        -> cv2.typing.MatLike: ...

**输入图像 (src)**‌:

类型：灰度图像（二维数组或矩阵）。

说明：需要进行边缘检测的源图像。

‌**阈值1 (threshold1)**‌:

类型：浮点数或整数。

说明：低阈值，用于双阈值检测中的较低阈值。

‌**阈值2 (threshold2)**‌:

类型：浮点数或整数。

说明：高阈值，用于双阈值检测中的较高阈值。通常是低阈值的两倍或三倍。

‌**边缘 (edges)**‌:

类型：二维数组或矩阵。

说明：用于存储检测到的边缘的输出图像。通常是一个与输入图像大小相同的二值图像。

‌**apertureSize (可选)**‌:

类型：整数。

说明：Sobel算子的大小，它决定了梯度计算的精度。默认值为3，表示使用3x3的Sobel算子。

‌**L2gradient (可选)**‌:

类型：布尔值。

说明：一个标志，指示是否使用更精确的L2范数进行梯度计算。如果为True，则使用L2范数；如果为False（默认），则使用L1范数。

返回值

Canny算子函数的返回值通常是检测到的边缘图像，它是一个二维数组或矩阵，包含了图像中的边缘信息。这个边缘图像通常是一个二值图像，其中边缘像素的值为非零（如255），非边缘像素的值为零。

代码演示

四、findContours函数与drawContours函数

findContours 函数是 OpenCV 中用于检测图像中轮廓（contours）的非常有用的函数。轮廓是图像中形状或物体的边界，它们对于图像分析、物体检测和识别等任务至关重要。
drawContours 函数是 OpenCV 中用于在图像上绘制轮廓的非常实用的函数。它可以将通过 findContours 函数检测到的轮廓绘制在原始图像或任何其他图像上，以便进行可视化或进一步的处理

功能

findContours 函数的主要功能是从二值图像中检测轮廓。这些轮廓可以表示图像中物体的边界，为后续的图像分析提供关键信息
drawContours 函数的主要功能是在图像上绘制一个或多个轮廓。这些轮廓通常是通过 findContours 函数从二值图像中检测到的，但也可以是由用户自定义的点集。

参数

python 复制代码

def findContours(image: cv2.typing.MatLike, 
                 mode: int,
                 method: int, 
                 contours: _typing.Sequence[cv2.typing.MatLike] | None = ...,
                 hierarchy: cv2.typing.MatLike | None = ..., 
                 offset: cv2.typing.Point = ...) \
        -> tuple[_typing.Sequence[cv2.typing.MatLike],
        cv2.typing.MatLike]: ...

‌**image (输入图像)**‌:

类型：二维数组（通常是二值图像）。

说明：需要进行轮廓检测的源图像。通常，这是通过阈值分割、边缘检测或其他二值化方法得到的图像。

‌**mode (轮廓检索模式)**‌:

类型：整数。

说明：指定轮廓检索的模式。常用的模式包括 cv2.RETR_EXTERNAL（只检索外部轮廓）、cv2.RETR_LIST（检索所有轮廓，但不创建任何父子关系）、cv2.RETR_CCOMP（检索所有轮廓，并将它们组织为两层结构，顶层是外部边界，底层是孔的边界）、cv2.RETR_TREE（检索所有轮廓，并重建完整的层次结构）。

‌**method (轮廓近似方法)**‌:

类型：整数。

说明：指定轮廓近似的方法。常用的方法包括 cv2.CHAIN_APPROX_NONE（存储所有的轮廓点，不进行任何近似）、cv2.CHAIN_APPROX_SIMPLE（压缩水平、垂直和对角线段，只保留它们的终点）、cv2.CHAIN_APPROX_TC89_L1、cv2.CHAIN_APPROX_TC89_KCOS（使用 Teh-Chin 链式近似算法）。

‌**contours (输出轮廓)**‌:

类型：列表的列表。

说明：这是一个输出参数，用于存储检测到的轮廓。每个轮廓都是一个点的列表，这些点表示了轮廓的边界。

‌**hierarchy (轮廓的层次结构, 可选)**‌:

类型：NumPy 数组。

说明：这是一个输出参数，用于存储轮廓之间的层次关系。如果不需要层次信息，可以将其设置为 None。

‌**offset (轮廓点的偏移量, 可选, 在某些版本中可能不可用)**‌:

类型：元组（两个整数）。

说明：指定轮廓点的偏移量。这个参数在某些版本的 OpenCV 中可能不可用，或者其用法可能有所不同。

python 复制代码

def drawContours(image: cv2.typing.MatLike,
                 contours: _typing.Sequence[cv2.typing.MatLike],
                 contourIdx: int,
                 color: cv2.typing.Scalar, 
                 thickness: int = ...,
                 lineType: int = ...,
                 hierarchy: cv2.typing.MatLike | None = ..., 
                 maxLevel: int = ..., 
                 offset: cv2.typing.Point = ...) \
        -> cv2.typing.MatLike: ...

‌**image (目标图像)**‌:

类型：三维数组（通常是彩色图像，但也可以是灰度图像）。

说明：要在其上绘制轮廓的图像。这个图像将被修改，以包含绘制的轮廓。

‌**contours (轮廓列表)**‌:

类型：列表的列表，其中每个内部列表都包含表示轮廓的点。

说明：要绘制的轮廓列表。这些轮廓通常是通过 findContours 函数获取的。

‌**contourIdx (轮廓索引)**‌:

类型：整数。

说明：指定要绘制的轮廓的索引。如果设置为 -1，则绘制所有轮廓。

‌**color (轮廓颜色)**‌:

类型：元组（三个整数，表示 BGR 颜色值）。

说明：轮廓的颜色。在 OpenCV 中，颜色通常以 BGR（蓝、绿、红）格式指定，而不是常见的 RGB 格式。

‌**thickness (轮廓线宽)**‌:

类型：整数。

说明：轮廓线的宽度。如果设置为 -1（或某些负值，具体取决于 OpenCV 版本），则轮廓内部将被填充。

‌**lineType (线条类型, 可选)**‌:

类型：整数。

说明：线条的类型，例如 cv2.LINE_8（8-连通线）、cv2.LINE_4（4-连通线）或 cv2.LINE_AA（抗锯齿线）。默认值是 cv2.LINE_8。

‌**hierarchy (轮廓层次结构, 可选)**‌:

类型：NumPy 数组。

说明：与轮廓列表相关联的层次结构信息。这个参数通常与 findContours 函数一起使用，但在 drawContours 中通常是可选的，因为绘制轮廓时通常不需要层次信息。

‌**maxLevel (最大层次深度, 可选, 某些版本中可能不可用)**‌:

类型：整数。

说明：指定要绘制的轮廓的最大层次深度。这个参数在某些版本的 OpenCV 中可能不可用。

‌**offset (轮廓点偏移量, 可选, 某些版本中可能不可用)**‌:

类型：元组（两个整数）。

说明：指定轮廓点的偏移量。这个参数在某些版本的 OpenCV 中可能不可用，或者其用法可能有所不同。

返回值

‌contours‌: 检测到的轮廓列表。每个轮廓都是一个点的列表（或 NumPy 数组），表示了轮廓的边界。

‌hierarchy‌: 轮廓之间的层次关系（如果请求了的话）。这是一个 NumPy 数组，包含了关于轮廓之间如何相互关联的信息。
cv2.typing.MatLike :输出图像。如果 dst 参数不为 None，则此输出图像与 dimage参数指向的图像相同；否则，函数会返回一个新的图像。

代码演示

python 复制代码

import cv2

img = cv2.imread('./tubao.png')
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
_, img_binary = cv2.threshold(img_gray,125,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# 寻找轮廓
contours,hierarchy = cv2.findContours(img_binary,
                                      cv2.RETR_EXTERNAL, # 查询轮廓方式
                                      cv2.CHAIN_APPROX_SIMPLE) # 保存轮廓点坐标的方式

img_copy = img.copy()
# 绘制轮廓
img_draw = cv2.drawContours(img_copy, # 要绘制轮廓的图像
                            contours, # 轮廓坐标顶点坐标集合
                            -1, # 轮廓集合的索引
                            (255,0,0), # 轮廓颜色
                            3) # 轮廓粗细

cv2.imshow('image_binary',img_binary)
cv2.imshow('img_copy',img_copy)
cv2.waitKey(0)

五、透视变换矩阵函数

getPerspectiveTransform 函数是 OpenCV 中用于计算透视变换矩阵的关键函数。这个函数接受源点集（src）和目标点集（dst），然后计算出一个变换矩阵，该矩阵可以将源点集中的点映射到目标点集中的相应点。下面是对 getPerspectiveTransform 函数的详细解释，包括其功能、参数、返回值以及应用。
warpPerspective 函数是 OpenCV 中用于对图像进行透视变换的关键函数。它接受一个源图像（src）、一个透视变换矩阵（M）、一个目标图像的大小（dsize），以及可选的目标图像（dst）、插值方法（flags）、边界模式（borderMode）和边界值（borderValue），然后返回透视变换后的图像。

功能

getPerspectiveTransform 函数的主要功能是计算一个透视变换矩阵，该矩阵可以将一个平面上的点集映射到另一个平面上的点集。这种变换在图像拼接、图像矫正、增强现实等应用中非常有用。
warpPerspective 函数的主要功能是对源图像进行透视变换，使其看起来像是从另一个角度或位置拍摄的。这种变换在图像拼接、图像矫正、3D效果模拟等应用中非常有用。

参数

python 复制代码

def getPerspectiveTransform(src: cv2.typing.MatLike,
                            dst: cv2.typing.MatLike, 
                            solveMethod: int = ...) \
        -> cv2.typing.MatLike: ...

‌**src (源点集)**‌:

类型：cv2.typing.MatLike，通常是一个包含四个二维点（通常是浮点型）的 NumPy 数组或类似结构。

说明：源点集，表示要进行透视变换的原始图像或平面中的四个点。这些点通常按照某种顺序排列，例如顺时针或逆时针。

‌**dst (目标点集)**‌:

类型：cv2.typing.MatLike，与源点集相同，也是一个包含四个二维点的 NumPy 数组或类似结构。

说明：目标点集，表示透视变换后的图像或平面中的四个点。这些点应该与源点集中的点一一对应。

‌**solveMethod (求解方法, 可选)**‌:

类型：整数。

说明：指定用于计算透视变换矩阵的求解方法。在 OpenCV 中，通常使用 cv2.DECOMP_LU、cv2.DECOMP_QR、cv2.DECOMP_NORMAL 等方法。如果省略此参数，OpenCV 将选择一种默认的方法。

python 复制代码

def warpPerspective(src: cv2.typing.MatLike,
                    M: cv2.typing.MatLike, 
                    dsize: cv2.typing.Size,
                    dst: cv2.typing.MatLike | None = ..., 
                    flags: int = ...,
                    borderMode: int = ...,
                    borderValue: cv2.typing.Scalar = ...) \
        -> cv2.typing.MatLike: ...

‌**src (源图像)**‌:

类型：cv2.typing.MatLike，通常是一个包含图像数据的 NumPy 数组或类似结构。

说明：要进行透视变换的源图像。

‌**M (透视变换矩阵)**‌:

类型：cv2.typing.MatLike，通常是一个 3x3 的浮点型矩阵。

说明：透视变换矩阵，可以通过 getPerspectiveTransform 函数计算得到。

‌**dsize (目标图像大小)**‌:

类型：cv2.typing.Size，是一个包含两个整数的元组或类似结构。

说明：透视变换后目标图像的大小，以像素为单位。

‌**dst (目标图像, 可选)**‌:

类型：cv2.typing.MatLike 或 None。

说明：如果提供，则透视变换后的图像将存储在这个参数中。如果为 None，则函数将创建一个新的图像来存储结果。

‌**flags (插值方法, 可选)**‌:

类型：整数。

说明：指定用于图像插值的方法，例如 cv2.INTER_LINEAR、cv2.INTER_NEAREST、cv2.INTER_CUBIC 等。默认值是 cv2.INTER_LINEAR。

‌**borderMode (边界模式, 可选)**‌:

类型：整数。

说明：指定边界像素的外推方法，例如 cv2.BORDER_CONSTANT、cv2.BORDER_REFLECT 等。当图像进行透视变换后，有些像素可能会超出目标图像的边界，此时需要使用这种方法来处理这些像素。默认值是 cv2.BORDER_CONSTANT。

‌**borderValue (边界值, 可选)**‌:

类型：cv2.typing.Scalar，通常是一个包含三个整数的元组或类似结构，表示 BGR 颜色值。

说明：当 borderMode 设置为 cv2.BORDER_CONSTANT 时，这个参数指定了边界像素的颜色值。默认值是黑色 (0, 0, 0)。

返回值

getPerspectiveTransform 函数返回一个 cv2.typing.MatLike 对象，通常是一个 3x3 的浮点型矩阵，表示计算出的透视变换矩阵。这个矩阵可以用于将源点集中的点映射到目标点集中的点
warpPerspective 函数返回一个 cv2.typing.MatLike 对象，表示透视变换后的图像。

代码演示

python 复制代码

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


img  = cv2.imread('./youhua.png')
img_arr = np.array(img)
plt.imshow(img_arr)
# points1 = np.array([[200,120],[700,170],[140,400],[650,460]],dtype=np.float32)
points1 =np.array([[174,141],[622,35],[88,493],[652,550]],dtype=np.float32)
points2 = np.array([[0,0],[img.shape[1],0],[0,img.shape[0]],[img.shape[1],img.shape[0]]],dtype=np.float32)
M = cv2.getPerspectiveTransform(points1,points2)
img_Perspective = cv2.warpPerspective(img,M,(img.shape[1],img.shape[0]))
cv2.imshow('img_',img_Perspective)
cv2.imshow('image',img)
cv2.waitKey(0)
plt.show()

复制代码

六、图像的外接边框

在图像处理中，轮廓的外接边界框（Bounding Box）是一个非常重要的概念，它通常用于表示轮廓的外部边界。外接边界框是一个简单的矩形，它完全包含轮廓内的所有点，并且其各边与图像的坐标轴平行。

‌轮廓‌：轮廓是图像中物体边缘的集合，通常通过边缘检测或轮廓检测算法得到。轮廓可以是不规则的形状，准确地反映了物体的外形。

‌外接边界框‌：外接边界框是一个完全包含轮廓的矩形，它的各边与图像的坐标轴平行。外接边界框不一定紧贴轮廓，但它一定包含轮廓内的所有点

用途‌：

轮廓通常用于图像分割、物体识别、形状分析等任务，因为它们提供了物体的精确边界信息。

外接边界框则更多地用于物体定位、跟踪、标注等任务，因为它们简化了物体的表示，使得处理和分析更加高效。

计算‌：

轮廓的计算通常涉及复杂的边缘检测或轮廓检测算法，如Canny边缘检测、Sobel算子、findContours函数等。

外接边界框的计算则相对简单，一旦得到轮廓的点集，只需要找到这些点的最小和最大x、y坐标，就可以确定外接边界框的位置和大小。

代码演示

python 复制代码

import cv2
import numpy as np

# 读取图片
img = cv2.imread('./outline.png')

img = cv2.resize(img,dsize=None,fx=0.8,fy=0.8)
# 灰度化
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
# 二值化
_,img_binary = cv2.threshold(img_gray,
                             127,
                             255,
                             cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

# 寻找论轮廓
c,v= cv2.findContours(img_binary,
                      cv2.RETR_LIST,
                      cv2.CHAIN_APPROX_SIMPLE)

# 绘制轮廓
img_copy = img.copy()
img_copy = cv2.drawContours(img_copy,
                            c,
                            -1,
                            (0,0,255),
                            2)


# 外接矩形
# 给所有轮廓都绘制
for cnt in c:

    x,y,w,h = cv2.boundingRect(cnt)# 调用外接矩形函数 获取左上角坐标（x，y) 和宽w，高h
    cv2.rectangle(img_copy,
                  [x,y],  # 左上角坐标
                  [x+w,y+h], # 右下角坐标
                  (255,255,0), # 矩形颜色
                  2          # 矩形线条粗细

    )

    # 调用最小面积外接矩形函数 获取包含中心点坐标 、长宽、旋转角度的三个元组
    ret = cv2.minAreaRect(cnt)
    box = np.int32(cv2.boxPoints(ret)) # 可以获取旋转矩阵的四个顶点

    cv2.drawContours(img_copy,[box],-1,(255,0,0),3)
    cv2.polylines(img_copy,[box],True,(255,255,0),1)

    # 调用最小外接圆的函数,获取圆心和半径
    (x,y),radius = cv2.minEnclosingCircle(cnt)
    (x,y,radius) = np.int32((x,y,radius))
    cv2.circle(img_copy,(x,y),radius,(0,255,255),2)

cv2.imshow('img',img)
cv2.imshow('img_copy',img_copy)

cv2.waitKey(0)

学习日志024--opencv中处理轮廓的函数

前言

一、 梯度处理的sobel算子函数

功能

参数

返回值

代码演示

二、梯度处理拉普拉斯算子

功能

参数

返回值

代码演示

三、Canny算子

功能

参数

返回值

代码演示

四、findContours函数与drawContours函数

功能

参数

返回值

代码演示

五、透视变换矩阵函数

功能

参数

返回值

代码演示

六、图像的外接边框

总结

一、梯度处理的sobel算子函数