python opencv图像处理相关函数

一、cv2.cvtColor

cv2.cvtColor(src, code, dst) 

用于将图像从一种颜色空间转换为另一种颜色空间。
参数说明：
1、src：要转换的输入图像。
2、code：转换的类型，表示源图像和目标图像之间的转换方式。常见的转换类型有：
cv2.COLOR_BGR2GRAY：将BGR彩色图像转换为灰度图像。
cv2.COLOR_BGR2RGB：将BGR彩色图像转换为RGB彩色图像。
cv2.COLOR_BGR2HSV：将BGR彩色图像转换为HSV彩色图像。
cv2.COLOR_BGR2Lab：将BGR彩色图像转换为Lab彩色图像。
cv2.COLOR_BGR2YUV：将BGR彩色图像转换为YUV彩色图像。
更多的转换类型可以在OpenCV文档中查找。
3、dst：输出图像，用于存储转换后的结果，python中不管。

二、cv2.rectangle

cv2.rectangle(img,pt1,pt2,color,thickness)

用于在任何图像上绘制矩阵。
参数说明：
1、img：背景图
2、pt1：直线起点坐标
3、pt2：直线终点坐标
4、color：当前绘画的颜色。如在BGR模式下，传递(255,0,0)表示蓝色画笔。灰度图下，只需要传递亮度值即可。
5、thickness：画笔的粗细，线宽。若是-1表示画封闭图像，如填充的圆。默认值是1.

三、cv2.circle

cv2.circle(image, center, radius, color, thickness)

用于在任何图像上绘制圆。
参数说明：
1、image：它是要在其上绘制圆的图像。
2、center：它是圆的中心坐标。坐标表示为两个值的元组，即(X坐标值，Y坐标值)。
3、radius：它是圆的半径。
4、color：它是要绘制的圆的边界线的颜色。对于BGR，我们通过一个元组。例如：(255，0，0)为蓝色。
5、thickness：它是圆边界线的粗细像素。厚度-1像素将以指定的颜色填充矩形形状。

四、cv2.ellipse

cv2.ellipse(image,centerCoordinates,axesLength,angle,startAngle,endAngle,color,thickness,lineType,shift)

用于在任何图像上绘制椭圆。
参数说明：
1、image：它是要在其上绘制椭圆的图像。
2、centerCoordinates：它是椭圆的中心坐标。坐标表示为两个值的元组，即(X坐标值，Y坐标值)。
3、axesLength：它包含两个变量的元组，分别包含椭圆的长轴和短轴(长轴长度，短轴长度)。
4、angle：椭圆旋转角度，以度为单位。
5、startAngle：椭圆弧的起始角度，以度为单位。
6、endAngle：椭圆弧的终止角度，以度为单位。
7、color：它是要绘制的形状边界线的颜色。对于BGR，我们通过一个元组。例如：(255，0，0)为蓝色。
8、thickness：是形状边界线的粗细像素。厚度-1像素将用指定的颜色填充形状。
9、lineType：这是一个可选参数，它给出了椭圆边界的类型。
10、shift：这是一个可选参数。它表示中心坐标中的小数位数和轴的值。

五、cv2.polylines

cv2.polylines(img, pts, isClosed, color, thickness)

OpenCV中用于绘制多边形的函数之一。它可以在给定的图像上绘制由多个线段组成的多边形。
参数说明：
1、img：需要在其上绘制多边形的图像。
2、pts：由多个点组成的多边形的顶点坐标，可以是一个NumPy数组或列表。
3、isClosed：一个布尔值，指示多边形是否封闭。如果是True，则绘制多边形的最后一个点将与第一个点相连，形成一个封闭的多边形。
4、color：多边形的颜色，可以是一个标量（在灰度图像中）或一个三元素元组（在彩色图像中）。
5、thickness：线条的厚度，单位为像素。

六、cv2.fillPoly

cv2.fillPoly(img, pts, color, lineType, shift, offset)

用来填充任意形状的图像，常常用于多边形的填充，可用于一个或者多个图形的填充
参数说明：
1、img：图片
2、pts：多边形坐标
3、color：填充颜色
4、lineType：线条类型。可以设为cv2.LINE_8（8-连通）、cv2.LINE_4（4-连通）或cv2.LINE_AA（反锯齿线条）。默认值为 cv2.LINE_8。
5、shift：点的精度。默认值为0
6、offset：偏移量。默认值为(0,0)。

七、cv2.copyMakeBorder

copyMakeBorder(src, top, bottom, left, right, borderType, dts, value)

在制作图像数据集时，有时需要调整图片的长和宽。采用cv2.resize函数会造成图像扭曲失真，因此需要采取填充图像短边的方法解决这个问题。
参数说明：
1、src：输入图像；
2、top：图像顶部需要填充的边界宽度，单位为像素；
3、bottom：图像底部需要填充的边界宽度，单位为像素；
4、left：图像左侧需要填充的边界宽度，单位为像素；
5、right：图像右侧需要填充的边界宽度，单位为像素；
6、borderType：填充类型，如cv2.BORDER_CONSTANT，用常数填充；cv2.BORDER_ISOLATED，用黑色像素填充，等；
7、dts：输出图像；
8、value：常量填充的值，如value=(114，114，114)，灰度填充。

八、cv2.threshold

retval, dst = cv2.threshold(src, thresh, maxval, type)

将输入的灰度图像进行阈值处理，将像素值与指定的阈值进行比较，并根据设定的阈值处理类型对像素进行处理。这个函数可以帮助我们将图像转换为二值图像，简化图像并提取感兴趣的信息。
参数说明：
1、src：输入图像，应为灰度图像。
2、thresh：阈值，用于对图像像素进行阈值处理。
3、maxval：阈值最大值，当像素值超过阈值时设置的像素值。
4、type：阈值处理类型，指定如何处理图像像素的阈值。

九、cv2.findContours

contours, hierarchy = cv2.findContours( image, mode, method)

查找图像轮廓。
参数说明：
1、mage：原始图像。8位单通道图像，所有非零值被处理为1，所有零值保持不变。也就是说灰度图像会被自动处理为二值图像。在实际操作时，可以根据需要，预先使用阈值处理等函数将待查找轮廓的图像处理为二值图像。
2、mode：轮廓检索模式。
cv2.RETR_EXTERNAL：只检测外轮廓。
cv2.RETR_LIST：对检测到的轮廓不建立等级关系。
cv2.RETR_CCOMP：检索所有轮廓并将它们组织成两级层次结构。上面的一层为外边界，下面的一层为内孔的边界。如果内孔内还有一个连通物体，那么这个物体的边界仍然位于顶层。
cv2.RETR_TREE：建立一个等级树结构的轮廓
3、method：轮廓的近似方法。

返回值说明：
1、contours：返回的轮廓。
2、hierarchy：图像的拓扑信息（轮廓层次）。

十、cv2.drawContours

cv2.drawContours(image, contours, contourIdx, color, thickness, lineType, hierarchy, maxLevel, offset)

根据轮廓数据在图像上绘制轮廓线条或填充轮廓
参数说明：
1、image: 要绘制轮廓的目标图像。这是一个多通道或单通道图像，通常是彩色图像（BGR）。
2、contours: 轮廓数据，是一个 Python 列表，包含所有轮廓的点集。每个轮廓本身也是一个点集，可以由 cv2.findContours() 函数获得。
3、contourIdx: 指定要绘制的轮廓的索引。如果是负值，则绘制所有轮廓。
4、color: 轮廓线条的颜色。对于彩色图像，使用 (B, G, R) 格式，例如 (0, 255, 0) 表示绿色。
5、thickness: 轮廓线条的厚度。如果为负值（如 cv2.FILLED），则填充轮廓内部。
6、lineType: 线条的类型，有 8（8-connected line）、4（4-connected line）和 cv2.LINE_AA（抗锯齿线）可选。
7、hierarchy（可选）: 轮廓层次结构，通常由 cv2.findContours() 返回。如果提供，该参数将用于绘制轮廓的层次结构。
8、maxLevel（可选）: 用于绘制轮廓层次结构的最大层次。默认值为 0，表示只绘制当前层次的轮廓。如果为负值，则绘制所有层次的轮廓。
9、offset（可选）: 轮廓点坐标的偏移量。默认值为 (0, 0)。

十一、cv2.floodFill

cv2.floodFill(image,mask,seedPoint,newVal,rect,loDiff,upDiff,flags)

漫水填充--用给定的颜色填充一个连通区域。
参数说明：
1、image：1或者3通道、 8bit或者浮点图像。仅当参数flags的FLOODFILL_MASK_ONLY标志位被设置时image不会被修改，否则会被修改。
2、mask：操作掩码，必须为单通道、8bit，且比image宽2个像素、高2个像素。使用前必须先初始化。Flood-filling无法跨越mask中的非0像素。例如，一个边缘检测的结果可以作为mask来阻止边缘填充。在输出中，mask中与image中填充像素对应的像素点被设置为1，或者flags标志位中设置的值(详见flags标志位的解释)。此外，该函数还用1填充了mask的边缘来简化内部处理。因此，可以在多个调用中使用同一mask，以确保填充区域不会重叠。
3、seedPoint：起始像素点。
4、newVal：重绘像素区域的新的填充值(颜色)。
5、rect：可选输出参数，返回重绘区域的最小绑定矩形。
6、loDiff：当前选定像素与其连通区中相邻像素中的一个像素，或者与加入该连通区的一个seedPoint像素，二者之间的最大下行差异值。
7、upDiff：当前选定像素与其连通区中相邻像素中的一个像素，或者与加入该连通区的一个seedPoint像素，二者之间的最大上行差异值。
8、flags：flags标志位是一个32bit的int类型数据，其由3部分组成：0-7bit表示邻接性(4邻接、8邻接)；8-15bit表示mask的填充颜色；16-31bit表示填充模式（详见填充模式解释）
9、填充模式说明：
FLOODFILL_FIXED_RANGE：如果设置了该值，则考虑当前像素与seed像素之间的差异，否则考虑相邻像素之间的差异(即浮动区间)。
FLOODFILL_MASK_ONLY：如果设置了该值，floodFill函数不会修改image的内容(newVal被忽略)，只使用flags标志中bit8 - 15
的值填充mask。该选项仅在含mask参数的floodFill函数中有效。

十二、示例代码

import cv2
import numpy as np
from ch3.my_cv_util import MyCvUtil


class OpenCvDemo(object):
    def __init__(self):
        self.win_name = 'img_test'
        self.win_title = '图像处理模块'
        self.img_test = cv2.imread("test.jpg", cv2.IMREAD_COLOR)

    def show_img_test(self):
        cv2.imshow(self.win_name,self.img_test)
        MyCvUtil.set_win_title(self.win_name, self.win_title)

    def cvtColor(self):
        img_gray = cv2.cvtColor(self.img_test, cv2.COLOR_BGR2GRAY)
        img_hsv = cv2.cvtColor(self.img_test, cv2.COLOR_BGR2HSV)
        self.show_img_test()
        cv2.imshow("img_gray", img_gray)
        MyCvUtil.set_win_title("img_gray", "灰度图")
        cv2.imshow("img_hsv", img_hsv)
        MyCvUtil.set_win_title("img_hsv", "HSV颜色空间")

    def rectangle(self):
        img = cv2.rectangle(self.img_test, (10, 10), (30, 30), (0, 0, 255), 1)
        cv2.imwrite("res.jpg", img)
        cv2.imshow("res", img)

    def circle(self):
        cv2.circle(self.img_test, (16, 16), 10, (0, 0, 255), -1)
        cv2.circle(self.img_test, (35, 40), 10, (0, 0, 255), 4)
        cv2.circle(self.img_test, (60, 60), 60, (0, 0, 255), 0)
        self.show_img_test()

    def ellipse(self):
        """
        cv2.ellipse(image, centerCoordinates, axesLength, angle, startAngle, endAngle, color, thickness, lineType, shift)
        image:它是要在其上绘制椭圆的图像。
        centerCoordinates:它是椭圆的中心坐标。坐标表示为两个值的元组，即(X坐标值，Y坐标值)。
        axesLength:它包含两个变量的元组，分别包含椭圆的长轴和短轴(长轴长度，短轴长度)。
        angle:椭圆旋转角度，以度为单位。
        startAngle:椭圆弧的起始角度，以度为单位。
        endAngle:椭圆弧的终止角度，以度为单位。
        color:它是要绘制的形状边界线的颜色。对于BGR，我们通过一个元组。例如：(255，0，0)为蓝色。
        thickness:是形状边界线的粗细像素。厚度-1像素将用指定的颜色填充形状。
        lineType:这是一个可选参数，它给出了椭圆边界的类型。
        shift:这是一个可选参数。它表示中心坐标中的小数位数和轴的值。
        """
        color_red = (0, 0, 255)
        cv2.ellipse(self.img_test, (45, 45), (40, 25), 0, 0, 360, color_red, 5, cv2.LINE_8)
        cv2.ellipse(self.img_test, (45, 45), (25, 12), 90, 0, 360, color_red, 5, cv2.LINE_8)
        cv2.ellipse(self.img_test, (45, 32), (28, 12), 0, 0, 360, color_red, 5, cv2.LINE_8)
        self.show_img_test()

    @staticmethod
    def ellipse2():
        win_width = 800
        win_height = 600
        img = np.zeros((win_height, win_width, 3), np.uint8)
        center = (win_width // 2, win_height // 2)
        # 绘制椭圆
        cv2.ellipse(img, center, (50, 12), 90, 0, 360, (255, 129, 0), thickness=2, lineType=cv2.LINE_8)
        cv2.ellipse(img, center, (50, 12), 0, 0, 360, (255, 129, 0), 2, cv2.LINE_8)
        cv2.ellipse(img, center, (50, 12), 45, 0, 360, (255, 129, 0), 2, cv2.LINE_8)
        cv2.ellipse(img, center, (50, 12), 135, 0, 360, (255, 129, 0), 2, cv2.LINE_8)
        # 绘制圆心
        cv2.circle(img, center, 5, (0, 0, 255), -1, cv2.LINE_8)
        win_name = 'img'
        cv2.imshow(win_name, img)
        MyCvUtil.set_win_title(win_name, '椭圆绘制')
        MyCvUtil.set_win_center(win_name, win_width, win_height)

    def polylines(self):
        pts = np.array([[10, 5], [20, 30], [70, 20], [50, 10]], np.int32)
        cv2.polylines(self.img_test, [pts], True, (0, 0, 255), 2)
        self.win_title = '多边形绘制'
        self.show_img_test()

    def fillPoly(self):
        triangle = np.array([[10, 30], [40, 80], [10, 90]], np.int32)
        cv2.fillPoly(self.img_test, [triangle], (255, 0, 0))
        self.win_title = '多边形填充'
        self.show_img_test()

    @staticmethod
    def draw_text_demo():
        img = np.zeros([512, 512, 3], dtype=np.uint8)
        for i in range(512):
            for j in range(512):
                img[i, j, :] = [i % 256, j % 256, (i + j) % 256]
        MyCvUtil.draw_text(img, 'hello world!')
        img = MyCvUtil.draw_ch_text(img, '你好，世界。', (100, 100), (255, 0, 0), 16)
        cv2.imshow('img', img)
        MyCvUtil.set_win_title('img', '文本绘制')

    @staticmethod
    def copyMakeBorder():
        img = cv2.imread('test.jpg')
        MyCvUtil.show_img_win(img, 'origin')
        # cv2.copyMakeBorder用来为图形设置边界
        # cv2.BORDER_REPLICATE 进行复制的补零操作， 只对边缘的点进行复制，然后该列上的点都是这些
        replicate = cv2.copyMakeBorder(img, 20, 20, 20, 20, cv2.BORDER_REPLICATE)
        MyCvUtil.show_img_win(replicate, 'replicate')
        constant = cv2.copyMakeBorder(img, 20, 20, 20, 20, cv2.BORDER_CONSTANT, value=(255, 0, 255))
        MyCvUtil.show_img_win(constant, 'constant')
        # cv2.BORDER_REFLECT 进行翻转的补零操作，举例只对当前对应的边缘
        reflect = cv2.copyMakeBorder(img, 20, 20, 20, 20, cv2.BORDER_REFLECT)
        MyCvUtil.show_img_win(reflect, 'reflect')
        # cv2.BORDER_REFLECT_101 进行翻转的补零操作
        reflect101 = cv2.copyMakeBorder(img, 20, 20, 20, 20, cv2.BORDER_REFLECT_101)
        MyCvUtil.show_img_win(reflect101, 'reflect101')
        # cv2.BORDER_WRAP 进行上下边缘调换的外包复制操作
        wrap = cv2.copyMakeBorder(img, 20, 20, 20, 20, cv2.BORDER_WRAP)
        MyCvUtil.show_img_win(wrap, 'wrap')

    @staticmethod
    def drawContours():
        img = cv2.imread("test2.jpg")
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        # 阈值的作用是根据设定的值处理图像的灰度值，比如灰度大于某个数值像素点保留。通过阈值以及有关算法可以实现从图像中抓取特定的图形，比如去除背景等。
        ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
        # cv2.imshow('binary', binary)
        # contours, hierarchy = cv2.findContours( image, mode, method)
        # contours为检测到的轮廓列表，hierarchy为轮廓的层级关系列表，每个轮廓对应一个列表[Next，Previous，First_Child，Parent]
        # cv2.RETR_EXTERNAL：只检测外轮廓。
        # cv2.RETR_LIST：对检测到的轮廓不建立等级关系。
        # cv2.RETR_CCOMP：检索所有轮廓并将它们组织成两级层次结构。上面的一层为外边界，下面的一层为内孔的边界。
        # 如果内孔内还有一个连通物体，那么这个物体的边界仍然位于顶层。
        # cv2.RETR_TREE：建立一个等级树结构的轮廓
        contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
        cv2.drawContours(img, contours, -1, (0, 0, 255), 3)
        cv2.imshow("img", img)
        MyCvUtil.set_win_title('img', '边缘检测')

    @staticmethod
    def floodFill():
        image = np.zeros((400, 400, 3), np.uint8)
        image[100:300, 100:300, :] = 255
        cv2.imshow("white", image)
        MyCvUtil.set_win_title("white", '原始图片')
        # mask必须为单通道、8bit，且比image宽2个像素、高2个像素。使用前必须先初始化
        mask = np.ones([402, 402, 1], np.uint8)
        mask[101:301, 101:301] = 0
        '''
        漫水填充--用给定的颜色填充一个连通区域
        image 【输入/输出】 1或者3通道、 8bit或者浮点图像。仅当参数flags的FLOODFILL_MASK_ONLY标志位被设置时image不会被修改，否则会被修改。
        mask 【输入/输出】 操作掩码，必须为单通道、8bit，且比image宽2个像素、高2个像素。使用前必须先初始化。
            Flood-filling无法跨越mask中的非0像素。例如，一个边缘检测的结果可以作为mask来阻止边缘填充。在输出中，
            mask中与image中填充像素对应的像素点被设置为1，或者flags标志位中设置的值(详见flags标志位的解释)。此外，
            该函数还用1填充了mask的边缘来简化内部处理。因此，可以在多个调用中使用同一mask，以确保填充区域不会重叠。
        seedPoint 起始像素点
        newVal   重绘像素区域的新的填充值(颜色)
        rect      可选输出参数，返回重绘区域的最小绑定矩形。
        loDiff     当前选定像素与其连通区中相邻像素中的一个像素，或者与加入该连通区的一个seedPoint像素，二者之间的最大下行差异值。
        upDiff    当前选定像素与其连通区中相邻像素中的一个像素，或者与加入该连通区的一个seedPoint像素，二者之间的最大上行差异值。
        flags     flags标志位是一个32bit的int类型数据，其由3部分组成： 
        0-7bit表示邻接性(4邻接、8邻接)；8-15bit表示mask的填充颜色；16-31bit表示填充模式（详见填充模式解释）
        FLOODFILL_FIXED_RANGE：如果设置了该值，则考虑当前像素与seed像素之间的差异，否则考虑相邻像素之间的差异(即浮动区间)。
        FLOODFILL_MASK_ONLY：如果设置了该值，floodFill函数不会修改image的内容(newVal被忽略)，只使用flags标志中bit8 - 15
        的值填充mask。该选项仅在含mask参数的floodFill函数中有效。
        '''
        mask_fill = 255
        flags = 4 | (mask_fill << 8) | cv2.FLOODFILL_FIXED_RANGE
        cv2.floodFill(image, mask, (200, 200), (0, 0, 255), flags=flags)
        cv2.imshow("red", image)
        MyCvUtil.set_win_title("red", '漫水填充后的图片')


if __name__ == '__main__':
    openCvDemo = OpenCvDemo()
    # openCvDemo.cvtColor()
    # openCvDemo.rectangle()
    # openCvDemo.circle()
    # openCvDemo.ellipse()
    # openCvDemo.ellipse2()
    # openCvDemo.polylines()
    # openCvDemo.fillPoly()
    # openCvDemo.draw_text_demo()
    openCvDemo.copyMakeBorder()
    # openCvDemo.drawContours()
    # openCvDemo.floodFill()

    cv2.waitKey(0)
    cv2.destroyAllWindows()