devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【小白起飞】Python OpenCV 从入门到实践（1~3）_pythonopencv从入门到精通 明日科技

作者：羊村懒王 | 2024-06-04 19:51:22

赞

踩

pythonopencv从入门到精通 明日科技

目录

1. 图像处理的基本操作

1.1 读取图像

1.2 显示图像

1.3 保存图像

1.4 获取图像属性

2. 图像数字化基础

2.1 像素

2.2 色彩空间

2.3 通道

2.4 使用NumPy模块操作像素

3. 绘制图像

3.1 线段的绘制

3.2 矩形的绘制

3.3 圆形的绘制

3.4 多边形的绘制

3.5 文字的绘制

3.6 动态绘制图像

         

                                                如果你交给某人一个程序，

                                                你将折磨他一整天；

                                                如果你教某人如何编写程序，

                                                你将折磨他一辈子。

                                                                        ——David Leinweber

1. 图像处理的基本操作

1.1 读取图像

image = cv2. imread(filename, flags)

参数说明：
image：imread()方法的返回值，返回的是读取到的图像。
filename：要读取的图像的完整文件名。
flags：读取图像颜色类型的标记。当flags的默认值为1时，表示读取的是彩色图像，此时的flags值可以省略；当flags的值为0时，表示读取的是灰度图像，或彩色图像转换后的灰度图像。

1.2 显示图像

OpenCV提供了imshow()方法，waitKey()方法和destroyAllWindows()来显示图像。

（1）imshow()方法用于显示图像

  1. # imshow()方法用于显示图像
  2. cv.imshow(winname, mat)
  3.  
  4. # waitKey()方法用于等待用户按下键盘上按键的时间。当用户按下键盘上的任意按键时，
  5. # 将执行 waitKey()方法, 并且获取 waitKey()方法的返回值。
  6. retval = cv2.waitKey(delay)

参数说明：
winname：显示图像的窗口名称
mat：要显示的图像

（2）waitKey()方法用于等待用户按下键盘上按键的时间。当用户按下键盘上的任意键时，将执行waitKey()方法，并获取waitKey()方法的返回值。

retval = cv2.waitKey(delay)

参数说明：
retval：与被按下的按键相应的ASCII码。例如，ESC键的ASCII码是27，当用户按下ESC时，waitKey()方法的返回值是27。如果没有被按下，waitKey()方法的返回值是-1。
delay：等待用户按下键盘的时间，单位为毫秒（ms）。当delay的值为复数、0或者为空时，表示无限等待用户按下按键的时间。

（3）destroyAllWindows()方法用于销毁所有正在显示图像的窗口。

cv2.destroyAllWindows()

示例：

  1. import cv2
  2.  
  3. image = cv2.imread("1.1.jpg") # 读取1.1.jpg
  4. cv2.imshow("flower", image) # 在名为flower的窗口中显示1.1.jpg
  5. cv2.waitKey() # 窗口将一直显示图像，等价于cv2.waitKey(0)
  6. cv2.destroyAllWindows() # 销毁所有窗口
  7.  
  8. # 注意：显示图像的窗口名称不能为中文，若为中文，则显示的图像窗口名称乱码。

程序结果

1.3 保存图像

cv2.imwrite(filename, img)

参数说明：
filename：保存图像时所用的完整路径。
img：要保存的图像

1.4 获取图像属性

OpenCV提供了shape、size、和dtype三个常用属性。

shape： 如果是彩色图像， 那么获取的是一个由图像的像素列数、像素行数和通道数所组成的数组， 如果是灰度图像， 那么获取的是一个包含图像的像素列数、像素行数的数组， 即(像素行数， 像素列数)。
size： 获取的是图像包含的像素个数，其值为“像素列数×像素行数×通道数”。(灰度图像的通道数为1)
dtype：获取的是图像的数据类型。

示例：

  1. import cv2
  2.  
  3. image_Color = cv2.imread("1.1.jpg") # 读取1.1.jpg
  4. print("获取彩色图像的属性：")
  5. print("shape =", image_Color.shape) # 打印彩色图像的（垂直像素，水平像素，通道数）
  6. print("size =", image_Color.size) # 打印彩色图像包含的像素个数
  7. print("dtype =", image_Color.dtype) # 打印彩色图像的数据类型
  8. image_Gray = cv2.imread("1.1.jpg", 0) # 读取与1.1.jpg（彩色图像）对应的灰度图像
  9. print("获取灰度图像的属性：")
  10. print("shape =", image_Gray.shape) # 打印灰度图像的（垂直像素，水平像素）
  11. print("size =", image_Gray.size) # 打印灰度图像包含的像素个数
  12. print("dtype =", image_Gray.dtype) # 打印灰度图像的数据类型

2. 图像数字化基础

2.1 像素

  1. import cv2
  2.  
  3. # 确定像素位置
  4. image = cv2.imread("D:/2.1.jpg") # 读取D盘根目录下的2.1.jpg
  5. px = image[291, 218] # 坐标为(291, 218)上的像素
  6.  
  7. # 获取像素的BGR坐标
  8. print("坐标（291，218）上的像素的BGR值是", px)
  9.  
  10. # 分别获取坐标(291，218)上像素的 B通道、G通道和 R通道的值
  11. image=cv2.imread("D:/2.1.jpg") 
  12. blue=image[291,218,0] #坐标(291,218)上的像素的B通道的值 
  13. green=image[291,218,1] #坐标(291,218)上的像素的G通道的值 
  14. red=image[291,218,2] #坐标(291,218)上的像素的R通道的值 
  15. print(blue,green,red)

修改图中指定区域的所有像素：

  1. import cv2
  2.  
  3. image = cv2.imread("2.1.jpg")
  4. cv2.imshow("2.1", image) # 显示图2.1
  5. for i in range(241, 292): # i表示横坐标，在区间[241, 291]内取值
  6.     for j in range(168, 219): # j表示纵坐标，在区间[168, 218]内取值
  7.         image[i, j] = [255, 255, 255] # 把区域内的所有像素都修改为白色
  8. cv2.imshow("2.8", image) # 显示图2.8
  9. cv2.waitKey()
  10. cv2.destroyAllWindows() # 关闭所有的窗口时，销毁所有窗口

                         

2.2 色彩空间

GRAY色彩空间：
        GRAY 色彩空间通常指的是灰度图像， 灰度图像是一种每个像素都是从黑到白， 被处理为 256个灰度级别的单色图像。这 256个灰度级别分别用区间 [0，255]中的数值表示。其中，“0”表示纯黑色，“255”表示纯白色， 0~255之间的数值表示不同亮度(即色彩的深浅程度)的深灰色或者浅灰色。因此， 一幅灰度图像能够展示丰富的细节信息。

从RGB/BGR色彩空间转换到GRAY色彩空间：

dst = cv2.cvtColor(src, code)

 参数说明：
dst：转换后的图像
src：转换前的初始图像
code：色彩空间转换码。cv2.COLOR_BGR2GRAY：从BGR色彩空间转换到GRAY色彩空间；cv2.COLOR_RGB2GRAY：从RGB色彩空间转换到GRAY色彩空间。

HSV色彩空间：
        BGR色彩空间是基于三基色而言的， 即红色、绿色和蓝色。而 HSV色彩空间则是基于色调、饱和度和亮度而言的。色调(H) 是指光的颜色， 例如，彩虹中的赤、橙、黄、绿、青、蓝、紫分别表示不同的色调，在 OpenCV中，色调在区间[0，180]内取值。例如，代表红色、黄色、绿色和蓝色的色调值分别为0、30、60和 120。饱和度 (S)是指色彩的深浅。在 OpenCV中，饱和度在区间[0，255]内取值。当饱和度为0时，图像将变为灰度图像。亮度(V)是指光的明暗。与饱和度相同, 在 OpenCV中,亮度在区间 [0,255]内取值。亮度值越大， 图像越亮； 当亮度值为0时， 图像呈纯黑色。
        当图像在RGB/BGR色彩空间与HSV色彩空间之间转换时，常用的色彩空间转换码有：cv2.COLOR_BGR2HSV和cv2.COLOR_RGB2HSV。

2.3 通道

为了拆分图像中的通道，OpenCV提供了split()方法。

b, g, r = cv2.split(bgr_img)

参数说明：
b：B通道图像
g：G通道图像
r： R通道图像
bgr_img：一幅BGR图像

示例：

  1. import cv2
  2.  
  3. rgb_image = cv2.imread("2.1.jpg")
  4. cv2.imshow("2.1", rgb_image) # 显示图2.1
  5. b, g, r = cv2.split(rgb_image) # 拆分图2.1中的通道
  6. cv2.imshow("B", b) # 显示图2.1中的B通道图像
  7. cv2.imshow("G", g) # 显示图2.1中的G通道图像
  8. cv2.imshow("R", r) # 显示图2.1中的R通道图像
  9. cv2.waitKey()
  10. cv2.destroyAllWindows()

        

 合并通道是拆分通道的逆过程，OpenCV提供了merge()方法来合并通道：

bgr = cv2.merge([b, g, r]) # 按照B→G→R合并通道

参数说明：
bgr：按B→G→R的顺序合并通道后得到的图像，合并顺序不同，图像的显示效果也不同
b：B通道图像
g：G通道图像
r： R通道图像

示例：

        将图2.1从BGR色彩空间转换到HSV色彩空间；然后拆分得到HSV图像中的通道；接着让S通道和V通道的值保持不变，让H通道的值调整为180；再接着合并拆分后的通道图像，将其从HSV色彩空间转换到BGR色彩空间，最后显示得到的BGR图像。

  1. import cv2
  2.  
  3. rgb_image = cv2.imread("2.1.jpg")
  4. cv2.imshow("2.1", rgb_image)
  5. # 从RGB色彩空间转换到HSV色彩空间
  6. hsv_image = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2HSV)
  7. h, s, v = cv2.split(hsv_image) # 拆分HSV图像中的通道
  8. h[:, :] = 180 # 将H通道的值调整为180
  9. hsv = cv2.merge([h, s, v]) # 合并拆分后的通道图像
  10. # 合并通道后的图像从HSV色彩空间转换到RGB色彩空间
  11. new_Image = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
  12. cv2.imshow("NEW",new_Image)
  13. cv2.waitKey()
  14. cv2.destroyAllWindows()

                                     

alpha通道。BGR色彩空间包含3个通道， 即B通道、G通道和R通道。OpenCV在这 3个通道的基础上，又增加了一个A通道， 即alpha通道，用于设置图像的透明度。这样，一个由B通道、G 通道、R通道和A通道这4个通道构成的色彩空间诞生了， 即 BGRA色彩空间。在 BGRA 色彩空间中， alpha通道在区间[0,255]内取值; 其中, 0表示透明, 255 表示不透明。PNG图像是一种典型的4通道（即B通道、G通道、R通道和A通道）图像。

2.4 使用NumPy模块操作像素

创建数组。NumPy提供了很多创建数组的方法：

numpy.array(object, dtype, copy, order, subok, ndmin)

参数说明：
object：任何具有数组接口方法的对象。
dtype：数据类型。
copy：可选参数，布尔型，默认值为 True，则 object对象被复制；否则，只有当 _array_ 返回副本，object参数为嵌套序列，或者需要副本满足数据类型和顺序要求时，才会生成副本。
order：元素在内存中的出现顺序， 值为K、A、C、F。如果object参数不是数组，则新创建的数组将按行排列(C)， 如果值为F， 则按列排列；如果 object参数是一个数组， 则以下成立：C(按行)、F(按列)、A(原顺序)、K(元素在内存中的出现顺序)。

示例：

  1. import numpy as np          #导入numpy模块
  2.  
  3. # 创建一维数组和二维数组
  4. n1 = np.array([1,2,3])      #创建一个简单的一维数组
  5. n2 = np.array([0.1,0.2,0.3])#创建一个包含小数的一维数组
  6. n3 = np.array([[1,2],[3,4]])#创建一个简单的二维数组
  7. print(n1)
  8. print(n2)
  9. print(n3)
  10.  
  11. # 创建浮点类型数组
  12. list = [1, 2, 3]  # 列表
  13. # 创建浮点型数组
  14. n4 = np.array(list, dtype=np.float_)
  15. # 或者
  16. n4 = np.array(list, dtype=float)
  17. print(n4)
  18.  
  19. # 创建三维数组
  20. nd1 = [1, 2, 3]
  21. nd2 = np.array(nd1, ndmin=3) #三维数组
  22. print(nd1)
  23.  
  24. # 创建2行3列的未初始化数组
  25. n5 = np.empty([2, 3])
  26. print(n5)
  27.  
  28. # 创建用0填充的数组
  29. n6 = np.zeros((3, 3), np.uint8)
  30. print(n6)
  31.  
  32. # 创建用1填充的数组
  33. n7 = np.ones((3, 3), np.uint8)
  34. print(n7)

 

 创建随机数组，randint()方法用于生成一定范围内的随机整数数组，左闭右开区间：

numpy.random.randint(low, high, size)

参数说明：
low：随机数最小取值范围
high：可选参数，随机数最大取值范围。若high为空，取值范围为（0，low)。若high不为空，则high必须大于low。
size：可选参数，数组维数。

示例：

  1. import numpy as np
  2. n1 = np.random.randint(1, 3, 10)
  3. print('随机生成10个1到3之间且不包括3的整数：')
  4. print(n1)
  5. n2 = np.random.randint(5, 10)
  6. print('size数组大小为空随机返回一个整数：')
  7. print(n2)
  8. n3 = np.random.randint(5, size=(2, 5))
  9. print('随机生成5以内二维数组')
  10. print(n3)

数组的索引和切片：

  1. # 查找数组n1索引为0的元素
  2. import numpy as np
  3. n1=np.array([1,2,3])  #创建一维数组
  4. print(n1[0])
[start:stop:step]

参数说明：
start：起始索引，若不写任何值，则表示从0开始的全部索引。
stop：终止索引，若不写任何值，则表示直到末尾的全部索引。
step：步长。

示例：

  1. import numpy as np
  2. n = np.array([0,1,2,3,4,5,6,7,8,9])
  3. print(n)
  4. print(n[:3])          # 0 1 2
  5. print(n[3:6])         # 3 4 5
  6. print(n[6:])          # 6 7 8 9
  7. print(n[::])          # 0 1 2 3 4 5 6 7 8 9
  8. print(n[:])           # 1 2 3 4 5 6 7 8 9
  9. print(n[::2])         # 0 2 4 6 8
  10. print(n[1::5])        # 1 6
  11. print(n[2::6])        # 2 8
  12. #start、stop、step为负数时
  13. print(n[::-1])        # 9 8 7 6 5 4 3 2 1 0
  14. print(n[:-3:-1])      # 9 8
  15. print(n[-3:-5:-1])    # 7 6
  16. print(n[-5::-1])      # 5 4 3 2 1 0

水平拼接数组和垂直拼接数组。hstack()方法可以对数组进行水平拼接，vstack()方法可以对数组进行垂直拼接：

  1. array1 = numpy.hstack(tup)
  2. array2 = numpy.vstack(tup)

参数说明：
tup：要拼接的数组元组。
array1：将参数元组中的数组水平拼接后生成的新数组。
array2：将参数元组中的数组垂直拼接后生成的新数组。

示例：

  1. import cv2
  2. import numpy as np
  3.  
  4. img = cv2.imread("stone.jpg")  # 读取原始图像
  5.  
  6. img_h = np.hstack((img, img))  # 水平拼接两个图像
  7. img_v = np.vstack((img, img))  # 垂直拼接两个图像
  8.  
  9. cv2.imshow("img_h", img_h)  # 展示拼接之后的效果
  10. cv2.imshow("img_v", img_v)
  11. cv2.waitKey()  # 按下任何键盘按键后
  12. cv2.destroyAllWindows()  # 释放所有窗体

3. 绘制图像

3.1 线段的绘制

OpenCV提供了绘制线段的line()方法，使用这个方法可以绘制长短不一、粗细各异、五颜六色的线段：

img = cv2.line(img, pt1, pt2, color, thickness)

参数说明：
img：画布
pt1：线段的起始点坐标
pt2：线段的终点坐标
color：绘制线段时的线条颜色
thickness：绘制线条时的线条宽度

示例：

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (300, 300, 3)：一个300 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((300, 300, 3), np.uint8)
  8. # 在画布上，绘制一条起点坐标为(50, 50)、终点坐标为(250, 50)，蓝色的，线条宽度为5的线段
  9. canvas = cv2.line(canvas, (50, 50), (250, 50), (255, 0, 0), 5)
  10. # 在画布上，绘制一条起点坐标为(50, 150)、终点坐标为(250, 150)，绿色的，线条宽度为10的线段
  11. canvas = cv2.line(canvas, (50, 150), (250, 150), (0, 255, 0), 10)
  12. # 在画布上，绘制一条起点坐标为(50, 250)、终点坐标为(250, 250)，红色的，线条宽度为15的线段
  13. canvas = cv2.line(canvas, (50, 250), (250, 250), (0, 0, 255), 15)
  14. # 在画布上，绘制一条起点坐标为(150, 50)、终点坐标为(150, 250)，黄色的，线条宽度为20的线段
  15. canvas = cv2.line(canvas, (150, 50), (150, 250), (0, 255, 255), 20)
  16. cv2.imshow("Lines", canvas) # 显示画布
  17. cv2.waitKey()
  18. cv2.destroyAllWindows()

3.2 矩形的绘制

OpenCV提供了绘制矩形的rectangle()方法，既可以绘制矩形边框，也可以绘制实心矩形：

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

参数说明：
img：画布
pt1：矩形的起始点坐标
pt2：矩形的终点坐标
color：绘制矩形时的线条颜色
thickness：绘制矩形时的线条宽度

示例：

绘制一个矩形边框

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (300, 300, 3)：一个300 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((300, 300, 3), np.uint8)
  8. # 在画布上绘制一个左上角坐标为(50,50)，右下角坐标为(200,150)，青色的，线条宽度为20的矩形边框
  9. canvas = cv2.rectangle(canvas, (50, 50), (200, 150), (255, 255, 0), 20)
  10. cv2.imshow("Rectangle", canvas) # 显示画布
  11. cv2.waitKey()
  12. cv2.destroyAllWindows()

绘制实心矩形

canvas = cv2.rectangle(canvas, (50, 50), (200, 150), (255, 255, 0), -1)

 

3.3 圆形的绘制

OpenCV提供了绘制矩形的circle()方法，既可以绘制圆形边框，也可以绘制实心圆形：

img = cv2.circle(img, center, radius, color, thickness)

参数说明：
img：画布
center：圆形的圆心坐标
radius：圆形的半径
color：绘制圆形时的线条颜色
thickness：绘制圆形时的线条宽度

示例：

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (100, 300, 3)：一个100 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((100, 300, 3), np.uint8)
  8. # 在画布上，绘制一个圆心坐标为(50, 50)，半径为40，红色的实心圆形
  9. canvas = cv2.circle(canvas, (50, 50), 40, (0, 0, 255), -1)
  10. # 在画布上，绘制一个圆心坐标为(150, 50)，半径为40，黄色的实心圆形
  11. canvas = cv2.circle(canvas, (150, 50), 40, (0, 255, 255), -1)
  12. # 在画布上，绘制一个圆心坐标为(250, 50)，半径为40，绿色的实心圆形
  13. canvas = cv2.circle(canvas, (250, 50), 40, (0, 255, 0), -1)
  14. cv2.imshow("TrafficLights", canvas) # 显示画布
  15. cv2.waitKey()
  16. cv2.destroyAllWindows()

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (300, 300, 3)：一个300 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((300, 300, 3), np.uint8)
  8. # shape[1]表示画布的宽度，center_X表示圆心的横坐标
  9. # 圆心的横坐标等于画布的宽度的一半
  10. center_X = int(canvas.shape[1] / 2)
  11. # shape[0]表示画布的高度，center_X表示圆心的纵坐标
  12. # 圆心的纵坐标等于画布的高度的一半
  13. center_Y = int(canvas.shape[0] / 2)
  14. # r表示半径；其中，r的值分别为0、30、60、90和120
  15. for r in range(0, 150, 30):
  16.     # 绘制一个圆心坐标为(center_X, center_Y)，半径为r，绿色的，线条宽度为5的圆形
  17.     cv2.circle(canvas, (center_X, center_Y), r, (0, 255, 0), 5)
  18. cv2.imshow("Circles", canvas) # 显示画布
  19. cv2.waitKey()
  20. cv2.destroyAllWindows()

3.4 多边形的绘制

OpenCV提供了绘制多边形的pololines()方法，使用这个方法绘制的多边形既可以是封闭的，也可以是不封闭的：

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

参数说明：
img：画布
pts：由多边形各个顶点的坐标组成的一个列表，列表是Numpy类型
isClosed：如果值为True，表示一个闭合的多边形，否则不闭合
color：绘制多边形时的线条颜色
thickness：线条宽度

示例：

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (300, 300, 3)：一个300 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((300, 300, 3), np.uint8)
  8. # 按顺时针给出等腰梯形4个顶点的坐标
  9. # 这4个顶点的坐标构成了一个大小等于“顶点个数 * 1 * 2”的数组
  10. # 这个数组的数据类型为np.int32
  11. pts = np.array([[100, 50], [200, 50], [250, 250], [50, 250]], np.int32)
  12. # 在画布上根据4个顶点的坐标，绘制一个闭合的，红色的，线条宽度为5的等腰梯形边框
  13. canvas = cv2.polylines(canvas, [pts], True, (0, 0, 255), 5)
  14. cv2.imshow("Polylines", canvas) # 显示画布
  15. cv2.waitKey()
  16. cv2.destroyAllWindows()

3.5 文字的绘制

OpenCV提供了用于绘制文字的putText()方法，使用这个方法不仅能够设置字体的样式、大小和颜色，而且能够使字体呈现斜体的效果， 还能够控制文字的方向，进而使文字呈现垂直镜像的效果：

  1. img = cv2.putText(img, text, org, fontFace, fontScale, color, thickness, ilneType, 
  2. bottomLeftOrigin)

参数说明：
img：画布
text：要绘制的文字内容
org：文字在画布中的左下角坐标
fontFace：字体样式
fontScale：字体大小
color：绘制文字时的线条颜色
thickness：绘制文字时的线条宽度
LineType：线型。（线的产生算法，有4和8两个值）
bottomLeftOrigin：绘制文字时的方向，有True和False两个值。默认Flase

示例：

  1. import numpy as np # 导入Python中的numpy模块
  2. import cv2
  3.  
  4. # np.zeros()：创建了一个画布
  5. # (100, 300, 3)：一个100 x 300，具有3个颜色空间（即Red、Green和Blue）的画布
  6. # np.uint8：OpenCV中的灰度图像和RGB图像都是以uint8存储的，因此这里的类型也是uint8
  7. canvas = np.zeros((100, 300, 3), np.uint8)
  8. # 在画布上绘制文字“mrsoft”，文字左下角的坐标为(20, 70)
  9. # 字体样式为FONT_HERSHEY_TRIPLEX
  10. # 字体大小为2，线条颜色是绿色，线条宽度为5
  11. cv2.putText(canvas, "mrsoft", (20, 70), cv2.FONT_HERSHEY_TRIPLEX, 2, (0, 255, 0), 5)
  12. cv2.imshow("Text", canvas) # 显示画布
  13. cv2.waitKey()
  14. cv2.destroyAllWindows()

3.6 动态绘制图像

动画实际上是由多幅图像在短时间之内交替放映实现的视觉效果。

示例：

  1. import cv2
  2. import time
  3. import numpy as np
  4.  
  5. width, height = 200, 200  # 画面的宽和高
  6. r = 20  # 圆半径
  7. x = r + 20  # 圆心和坐标起始坐标
  8. y = r + 100  # 圆形纵坐标起始坐标
  9. x_offer = y_offer = 4  # 每一帧的移动速度
  10.  
  11. while cv2.waitKey(1) == -1:  # 按下任何按键之后
  12.     if x > width - r or x < r:  # 如果圆的横坐标超出边界
  13.         x_offer *= -1  # 横坐标速度取相反值
  14.     if y > height - r or y < r:  # 如果圆的纵坐标超出边界
  15.         y_offer *= -1  # 纵坐标速度取相反值
  16.     x += x_offer  # 圆心按照横坐标速度移动
  17.     y += y_offer  # 圆心按照纵坐标速度移动
  18.     img = np.ones((width, height, 3), np.uint8) * 255  # 绘制白色背景面板
  19.     cv2.circle(img, (x, y), r, (255, 0, 0), -1)  # 绘制圆形
  20.     cv2.imshow("img", img)  # 显示图像
  21.     time.sleep(1 / 60)  # 休眠1/60秒，也就是秒60帧
  22.  
  23. cv2.destroyAllWindows()  # 释放所有窗体

          

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/673243
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号