k210相关图像操作

官方参考网址

1、Adaptive Histogram Equalization-直方图均衡

clip_limit为1，则没有效果。为了获得最佳效果，请将其设置为略高于 1，如下所示。您设置的值越高，就越接近具有巨大对比度的标准自适应直方图均衡。
img=sensor.snapshot().histeq(自适应性=True，剪辑限制=3)
打印(时钟格式)

1、1 代码

# 直方图均衡例子
#
# 此示例展示了如何使用直方图均衡来改善图像中的对比度。import sensor, image, timesensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()while(True):clock.tick()# A clip_limit of < 0 gives you normal adaptive histogram equalization# which may result in huge amounts of contrast noise...# A clip_limit of 1 does nothing. For best results go slightly higher# than 1 like below. The higher you go the closer you get back to# standard adaptive histogram equalization with huge contrast swings.img = sensor.snapshot().histeq(adaptive=True, clip_limit=3)print(clock.fps())

• 关键函数（需要放到初始化之后，while后面)：

img = sensor.snapshot().histeq(adaptive=True, clip_limit=3)
当clip_limit较小时，对比度增强的幅度也会变小，即会限制对比度的增加，使得整体图像的对比度变化较小。
当clip_limit较大时，对比度增强的幅度也会变大，即会允许更多的对比度增加，使得整体图像的对比度变化较大。

2、画关键点

2、1 代码：

# 这个例程展示如何在图像上画关键点，通常你可以直接调用draw_keypoints()，但是你也可以通过传入一个3值的元组来调用import sensor, image, time, urandomsensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QVGA)   # 设置摄像头输出大小为 QVGA (320x240)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 生成随机坐标for i in range(20):x = (urandom.getrandbits(30) % (2*img.width())) - (img.width()//2)y = (urandom.getrandbits(30) % (2*img.height())) - (img.height()//2)rot = urandom.getrandbits(30) % 360r = (urandom.getrandbits(30) % 127) + 128g = (urandom.getrandbits(30) % 127) + 128b = (urandom.getrandbits(30) % 127) + 128# 画关键点，传入[(x, y, rot)] 元组img.draw_keypoints([(x, y, rot)], color = (r, g, b), size = 20, thickness = 2, fill = False)print(clock.fps())              # 打印帧率

2、2 关键函数：

img.draw_keypoints([(x, y, rot)], color = (r, g, b), size = 20, thickness = 2, fill = False)

其中的rot是方向
rot = urandom.getrandbits(30) % 360
这段代码是使用Python标准库中的urandom模块生成一个30位的随机数，然后对360取余数。这意味着它会生成一个0到359之间的随机整数，即一个在0到359度范围内的随机角度。

具体地说，urandom.getrandbits(30)会生成一个30位的随机整数，然后 % 360会将这个整数限制在0到359之间。这样就可以得到一个随机的角度值，用于一些需要随机角度的应用场景，比如旋转、方向等。

2、3 /训练代码：

import sensor, image, lcd, time
import randomblack_area = (0, 42, -11, 24, -28, 46)
white_area = (100, 49, -5, 5, -5, 113)lcd.init()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_vflip(True)  # 垂直方向翻转
sensor.set_brightness(0)   # 设置亮度
sensor.set_contrast(1)  # 对比度
sensor.skip_frames(10)while True:img = sensor.snapshot()blobs_b = img.find_blobs([black_area], pixels_threshold=200, area_threshold=200)if blobs_b:max_blob = max(blobs_b, key=lambda b: b.w() * b.h())rect = max_blob.rect()img.draw_rectangle(rect, color=(255, 0, 0), thickness=3)  # 设置矩形边框的宽度为3个像素for B in blobs_b:rot = random.randint(0, 359)  # 生成0到359之间的随机角度img.draw_keypoints([(B[0], B[1], rot)], color=(0, 0, 255), size=20, thickness=2, fill=False)img.draw_keypoints([(B[0] + B[2], B[1], rot)], color=(0, 0, 255), size=20, thickness=2, fill=False)img.draw_keypoints([(B[0], B[1] + B[3], rot)], color=(0, 0, 255), size=20, thickness=2, fill=False)img.draw_keypoints([(B[0] + B[2], B[1] + B[3], rot)], color=(0, 0, 255), size=20, thickness=2, fill=False)lcd.clear()  # 清除LCD屏幕lcd.display(img)

这里的是矩形的四个顶点

3、Blur Filter-模糊滤波

• 去除噪声：图像可能受到来自传感器、环境或传输过程中的噪声影响，模糊滤波可以有效地减少这些噪声。

• 平滑图像：模糊滤波可以平滑图像中的过渡和边缘，使得图像看起来更加连续和柔和。

• 降低细节水平：在某些情况下你可能希望减少图像中的细节信息，模糊滤波可以帮助你实现这一点，从而突出图像中的关键特征。

3、1 代码

# 模糊滤波例程import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 在图像的每个像素上运行核。img.gaussian(1)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

3、2 关键代码

  # 在图像的每个像素上运行核。img.gaussian(1)

使用了高斯模糊（Gaussian Blur）来处理图像。高斯模糊是一种常见的模糊滤波方法，它通过对每个像素及其周围像素的加权平均来实现模糊效果。通过调整模糊核的大小，你可以控制模糊的程度。

4、Cartoon Filter - 卡通化滤波

4、1 代码：

# 卡通化滤波例程
# 此示例显示了图像上的简单卡通滤波器。卡通化滤波通过连接图像的相似
# 像素区域并用区域平均值替换这些区域中的像素来工作。import sensor, image, timesensor.reset()
sensor.set_pixformat(sensor.RGB565) # or GRAYSCALE...
sensor.set_framesize(sensor.QVGA) # or QQVGA...
sensor.skip_frames(time = 2000)
clock = time.clock()while(True):clock.tick()# seed_threshold控制着色区域的最大区域增长。 将其放大会合并更多像素。# floating_threshold控制增长区域时的最大像素到像素的差异。设置高的值将快速组合图像中的所有像素。你应该使其小一些。# cartoon() 将增长同时两个限制都满足的区域...img = sensor.snapshot().cartoon(seed_threshold=0.05, floating_thresholds=0.05)print(clock.fps())

4、2 关键代码

加了之后好卡

 img = sensor.snapshot().cartoon(seed_threshold=0.05, floating_thresholds=0.05)

4、3 应用场景

卡通滤镜的一些常见应用包括：艺术渲染：为艺术或创意项目创建卡通风格的图像。
视觉效果：出于娱乐或营销目的，为图像或视频添加独特且具有视觉吸引力的风格。
图像增强：强调轮廓并减少精细细节以简化视觉信息。
隐私保护：匿名或隐藏图像中的细节，同时仍然传达整个场景。
总体而言，当需要风格化或视觉上吸引人的图像表示时，通常使用卡通滤镜，并且它在艺术、设计、娱乐和图像处理中得到了应用。

5 Color Bilteral Filter - 彩图双边滤波

5.1 代码

# 双边滤波例程
# 此示例显示了在彩色图像上使用双边滤波。import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565)  # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# color_sigma controls how close color wise pixels have to be to each other to be# color_sigma控制彩色明智像素之间必须有多近的距离才能模糊。# blured togheter. A smaller value means they have to be closer.# 更小的值意味着它们必须更接近。# A larger value is less strict.# 较大的值不那么严格。# space_sigma controls how close space wise pixels have to be to each other to be# space_sigma控制空间智慧像素彼此之间必须有多近才能模糊# blured togheter. A smaller value means they have to be closer.# 更小的值意味着它们必须更接近。# A larger value is less strict.# 较大的值不那么严格。# Run the kernel on every pixel of the image.# 在图像的每个像素上运行核img.bilateral(3, color_sigma=0.1, space_sigma=1)# Note that the bilateral filter can introduce image defects if you set# color_sigma/space_sigma to aggresively. Increase the sigma values until# the defects go away if you see them.# 请注意，如果将color_sigma/space_sigma设置为聚合，双边过滤器可能会引入图像缺陷。# 如果你看到缺陷，增加sigma值直到缺陷消失print(clock.fps())  # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

5、2 解释和应用场景：

这段代码演示了在彩色图像上使用双边滤波器进行图像处理。以下是对代码中各部分的详细解释：sensor.reset(): 初始化摄像头模块。sensor.set_pixformat(sensor.RGB565): 设置摄像头输出格式为 RGB565（24位颜色）或 GRAYSCALE（灰度）。在此示例中，设置为 RGB565。sensor.set_framesize(sensor.QQVGA): 设置摄像头输出大小为 QQVGA（160x120像素）。sensor.skip_frames(time=2000): 跳过2000ms（2秒）的帧，以便让相机传感器适应光照条件。clock = time.clock(): 创建一个时钟对象来计算帧率。while(True): 无限循环，用于不断捕获并处理图像。clock.tick(): 计算一帧的处理时间。img = sensor.snapshot(): 从摄像头捕获一张图像。img.bilateral(3, color_sigma=0.1, space_sigma=1): 应用双边滤波器到图像。3：指定滤波器的尺寸。
color_sigma：控制颜色空间中像素之间的相似性。较小的值表示颜色需更接近才会被模糊。
space_sigma：控制空间中像素之间的相似性。较小的值表示空间需更接近才会被模糊。
print(clock.fps()): 打印每秒处理的帧数。双边滤波器是一种非常有用的图像处理技术，它能够平衡去噪和保持图像边缘细节。这种滤波器结合了颜色相似性和空间相似性，可有效地减少噪声，同时保持图像的清晰度和轮廓。应用场景包括：图像降噪: 双边滤波器可用于去除图像中的噪声，而且能够保留图像的细节。
图像增强: 可用于增强图像的轮廓和纹理，同时去除噪声。
美化效果: 在美化和风格化处理中，可用于使图像看起来更加柔和和自然。
医学图像处理: 在医学图像处理中也有重要应用，如去除CT或MRI图像中的噪声。
总的来说，双边滤波器在需要去除噪声同时保持图像细节的场合下非常有用，尤其适合对实时图像进行处理。

6、 Color Binary Filter - 二值化滤波

6、1 代码：

# 颜色二值化滤波例子
#
# 这个脚本展示了二值图像滤波。
# 您可以传递二进制任意的阈值来分割图像。import sensor, image, timesensor.reset()
sensor.set_framesize(sensor.QVGA)
sensor.set_pixformat(sensor.RGB565)
sensor.skip_frames(time = 2000)
clock = time.clock()#设置颜色阈值，如果是rgb图像，六个数字分别为(minL, maxL, minA, maxA, minB, maxB)；
#如果是灰度图，则只需设置（min, max）两个数字即可。
red_threshold = (0,100,   0,127,   0,127) # L A B
green_threshold = (0,100,   -128,0,   0,127) # L A B
blue_threshold = (0,100,   -128,127,   -128,0) # L A B#使用工具 - >机器视觉 - >阈值编辑器选择更好的阈值。
while(True):#测试红色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([red_threshold])print(clock.fps())#测试绿色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([green_threshold])print(clock.fps())#测试蓝色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([blue_threshold])print(clock.fps())#测试不是红色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([red_threshold], invert = 1)print(clock.fps())#测试不是绿色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([green_threshold], invert = 1)print(clock.fps())#测试不是蓝色阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([blue_threshold], invert = 1)print(clock.fps())

6、2 解释

这段代码展示了如何使用颜色阈值对图像进行二值化处理，并进行性能测试。以下是对代码中各部分的详细解释：sensor.reset(): 初始化摄像头模块。sensor.set_framesize(sensor.QVGA): 设置摄像头输出大小为 QVGA（320x240像素）。sensor.set_pixformat(sensor.RGB565): 设置摄像头输出格式为 RGB565（24位彩色）。sensor.skip_frames(time=2000): 跳过2000ms（2秒）的帧，以便让相机传感器适应光照条件。clock = time.clock(): 创建一个时钟对象来计算帧率。red_threshold, green_threshold, blue_threshold: 分别设置红色、绿色、蓝色的颜色阈值。用于指定在图像中用于二值化的颜色范围。while(True): 无限循环，用于不断捕获并处理图像。img.binary([threshold], invert=0): 对图像进行二值化处理。threshold: 指定用于二值化的颜色阈值。
invert: 控制是否反转二值化后的黑白图像。默认为0，表示不反转；设置为1则表示反转。
性能测试部分：分别对红色、绿色、蓝色阈值进行二值化处理，并输出每秒处理的帧数（fps）。具体步骤包括：通过循环多次使用红色、绿色、蓝色阈值进行二值化，并输出帧率。
通过添加invert=1参数，测试不是某种颜色的阈值的二值化效果。
总的来说，这段代码演示了如何使用颜色阈值对图像进行二值化处理，并通过性能测试评估不同阈值的处理速度。这种技术可用于在图像中检测特定颜色的物体或区域，同时排除其他颜色的干扰

当使用颜色空间的 L A B 表示进行阈值分割时，通常会使用 L、A 和 B 三个通道的数值范围来确定颜色的阈值。在这种表示中：L 通道代表图像的亮度（Luminance），其数值范围一般是 0 到 100。较小的值对应较暗的颜色，较大的值对应较亮的颜色。
A 通道代表红色和绿色之间的颜色范围，其数值范围一般是 -128 到 127。负值对应绿色，正值对应红色。
B 通道代表蓝色和黄色之间的颜色范围，其数值范围一般也是 -128 到 127。负值对应蓝色，正值对应黄色。
因此，red_threshold = (0,100,   0,127,   0,127) 这个参数中的具体含义是：L 通道的阈值范围为 0 到 100，表示选择亮度在 0 到 100 之间的颜色。
A 通道的阈值范围为 0 到 127，表示选择红色在 0 到 127 之间的颜色。
B 通道的阈值范围为 0 到 127，表示选择蓝色在 0 到 127 之间的颜色。
因此，这个阈值参数指定了一个范围，包括了 L 通道的整个范围以及 A 和 B 通道的部分范围，用于选择图像中的红色区域。

6、3 二值化应用：

和1）的形式。主要的使用场景包括：图像分割：二值化可以用于将图像分割成不同的区域，使得图像中的目标区域与背景区域在亮度或颜色方面有明显的差异。这对于物体检测、识别和分割等应用是非常有用的。特征提取：在图像处理中，二值化可以作为一种预处理步骤，用于提取图像中的特定特征。例如，通过对二值化图像应用形态学运算（如膨胀、腐蚀、开运算、闭运算等），可以增强或弱化图像中的某些特征，从而更容易提取出目标的形状、纹理等特征。文档图像处理：在文档图像处理中，二值化常用于将文本或图像分离出来，以便进行OCR（光学字符识别）或者其他文档分析任务。图像压缩：二值化可以将图像转换为黑白形式，从而减少图像的信息量，进而实现图像的压缩，适用于存储空间有限或者网络传输带宽有限的场景。图像增强：二值化可以突出图像中的某些细节，使其更易于观察和理解。例如，对于一些医学图像，将图像转换为黑白形式可以突出某些病灶区域，帮助医生做出诊断。总的来说，二值化在图像处理中具有广泛的应用，特别是在需要进行目标检测、图像分割、特征提取等任务时，常常会使用到二值化技术。

7、Color Light Removal - 彩图光线去除

去除明亮光线
img = sensor.snapshot().binary([thresholds], invert=False, zero=True)
使用 sensor.snapshot() 捕获图像，并使用 binary() 方法对图像进行二值化处理。
将阈值参数传递给 binary() 方法，以指定需要保留的亮度范围，将在该范围内的像素设置为高亮（白色），其他像素设置为低亮（黑色）。
设置 invert=False 表示保留高亮的像素，设置 zero=True 表示将其他像素设置为零。

7、1 代码

# 彩图光线去除例程
# 此示例显示如何从图像中删除明亮的灯光。
# 您可以使用带有“zero =”参数的binary()方法执行此操作。# 从图像中删除明亮的光线允许您在图像上使用histeq()，
# 而不会使图像的过饱和部分的异常值破坏算法...import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率thresholds = (90, 100, -128, 127, -128, 127)while(True):clock.tick() # 更新计算帧率的clockimg = sensor.snapshot().binary([thresholds], invert=False, zero=True)print(clock.fps()) # 打印帧率

参数变了之后全黑

8、Edge Filter - 边缘滤波

8、1 代码：

img = sensor.snapshot().laplacian(1)

# 边缘滤波
#
# 这个例子展示了边缘滤波。import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 在图像的每个像素上运行内核img.laplacian(1)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

8、2 背景

边沿滤波是一种图像处理技术，用于突出图像中的边缘信息。它通过在图像的每个像素上应用一个特定的内核或滤波器来实现。边沿滤波的作用是通过检测图像中的亮度变化来提取出图像中的边缘信息。当图像中存在明暗变化较大的区域时，边沿滤波可以将这些区域的边缘轮廓突出显示。在上述代码示例中，使用了拉普拉斯算子（Laplacian）作为边沿滤波器。拉普拉斯算子可以计算图像中各个像素点与其周围像素之间的差异，并将结果应用到原始图像上。这样做可以使得图像中的边缘部分更加清晰和鲜明。边沿滤波对于许多图像处理任务非常有用，包括边缘检测、目标识别、图像分割等。它可以帮助我们从图像中提取出重要的结构和特征，以便进行后续的分析和处理。

9 、Erode and Dilate - 腐蚀膨胀

grayscale_thres = (170, 255) 是一个用来定义灰度阈值的元组。在这个例子中，它用于将图像二值化，即将灰度图像转换为黑白图像。
具体来说，元组 (170, 255) 表示了两个阈值：最小阈值为 170，最大阈值为 255。在图像二值化的过程中，所有小于最小阈值的像素被设为黑色（0），而所有大于最大阈值的像素被设为白色（255）。介于两者之间的像素值将根据其与阈值的关系进行相应的处理。
img.dilate(2) 对图像边缘进行膨胀，膨胀函数image.dilate(size, threshold=Auto)，size为kernal的大小，使边缘膨胀。threshold用来设置去除相邻点的个数，threshold数值越大，边缘越膨胀；数值越小，边缘膨胀的小。
mage.dilate(size, threshold=Auto)，threshold用来设置去除相邻点的个数，threshold数值越大，边缘越膨胀；

。

9、1 代码

# 腐蚀和膨胀的例子
#
# 这个例子展示了可以在二进制图像上运行的腐蚀和膨胀函数来消除噪声。
# 这个例子最初是一个测试，但是它对于展示这些函数是如何工作的很有用。import sensor, imagesensor.reset()
sensor.set_framesize(sensor.QVGA)grayscale_thres = (170, 255)
rgb565_thres = (70, 100, -128, 127, -128, 127)while(True):sensor.set_pixformat(sensor.GRAYSCALE)for i in range(20):img = sensor.snapshot()#先对图像进行分割，二值化，将在阈值内的区域变为白色，阈值外区域变为黑色img.binary([grayscale_thres])#对图像边缘进行侵蚀，侵蚀函数erode(size, threshold=Auto)，size为#kernal的大小，去除边缘相邻处多余的点。threshold用来设置去除相邻点的个数，#threshold数值越大，被侵蚀掉的边缘点越多，边缘旁边白色杂点少；数值越小，#被侵蚀掉的边缘点越少，边缘旁边的白色杂点越多。img.erode(2)for i in range(20):img = sensor.snapshot()img.binary([grayscale_thres])img.dilate(2)#对图像边缘进行膨胀，膨胀函数image.dilate(size, threshold=Auto)，size为#kernal的大小，使边缘膨胀。threshold用来设置去除相邻点的个数，threshold数值#越大，边缘越膨胀；#数值越小，边缘膨胀的小。        sensor.set_pixformat(sensor.RGB565)for i in range(20):img = sensor.snapshot()img.binary([rgb565_thres])img.erode(2)for i in range(20):img = sensor.snapshot()img.binary([rgb565_thres])img.dilate(2)

10、Gamma Correction - Gamma 矫正

• 伽马矫正是一种用于调整图像亮度和对比度的方法。在这个例子中，gamma_corr() 方法被用来应用伽马校正，具体参数包括 gamma、contrast 和 brightness。
• gamma: 该参数可以控制图像的非线性亮度变换。较低的值会使图像更暗，较高的值会使图像更亮
• contrast: 调整图像对比度的参数。默认值为1.0，大于1.0会增加对比度，小于1.0会降低对比度。
• rightness: 控制图像亮度的参数。负值会使图像变暗，正值会使图像变亮
• 伽马矫正在图像处理中有很多具体应用，例如：
  _{显示优化：通过调整图像的亮度和对比度，可以增强图像的视觉效果，提高显示的清晰度和色彩鲜艳度。
  图像增强：在计算机视觉和图像处理中，伽马矫正可以用于增强图像的细节，并改善图像的质量。
  图像校正：在某些应用中，由于光照条件或摄像头特性的影响，图像可能出现亮度不均匀的情况，伽马校正可以用来调整图像的整体亮度分布。
  模式识别：在一些模式识别的应用中，伽马矫正可以用来减少背景噪音，增加目标的对比度，从而提高识别的准确率。}

总之，伽马矫正是图像处理中常用的一种技术，可以根据具体需求对图像进行亮度和对比度的调整，以达到更好的视觉效果或者图像处理结果。

10、1代码

# gamma矫正
#
# 此示例显示关闭伽玛校正以使图像更亮。
# 伽马校正方法也可以固定对比度和亮度。import sensor, image, timesensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()while(True):clock.tick()# 伽玛，对比度和亮度校正应用于每个颜色通道。# v这些值按比例缩放到每个图像类型的每个颜色通道的范围...img = sensor.snapshot().gamma_corr(gamma = 0.5, contrast = 1.0, brightness = 0.0)print(clock.fps())

11、Grayscale Binary Filter - 灰度二值化滤波

low_threshold = (0, 50)
high_threshold = (205, 255)

11、1 代码

# 灰度二值化例程
#
# 这个脚本展示了二值图像滤波。
# 这个脚本是很原始的测试，但是对于如何使用二值化还是很有用的。import sensor, image, timesensor.reset()
sensor.set_framesize(sensor.QVGA)
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.skip_frames(time = 2000)
clock = time.clock()low_threshold = (0, 50)
high_threshold = (205, 255)while(True):# 测试低阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([low_threshold])print(clock.fps())#image.binary(thresholds, invert=False)此函数将在thresholds内的#图像部分的全部像素变为1白，将在阈值外的部分全部像素变为0黑。invert将图像#的0 1（黑 白）进行反转，默认为false不反转。# 测试高阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([high_threshold])print(clock.fps())#测试不是低阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([low_threshold], invert = 1)print(clock.fps())#测试不是高阈值for i in range(100):clock.tick()img = sensor.snapshot()img.binary([high_threshold], invert = 1)print(clock.fps())

12 、Grayscale Light Removal - 移除灰度高亮

12、1 代码

# 灰度滤波例程
# 此示例显示如何从图像中删除明亮的灯光。
# 您可以使用带有“zero =”参数的binary()方法执行此操作。# 从图像中删除明亮的光线允许您在图像上使用histeq()，
# 而不会使图像的过饱和部分的异常值破坏算法...import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率thresholds = (220, 255)while(True):clock.tick() # 更新计算帧率的clockimg = sensor.snapshot().binary([thresholds], invert=False, zero=True)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

13、Histogram Equalization - 直方图均衡

img = sensor.snapshot().histeq(adaptive=True, clip_limit=3)
img = sensor.snapshot().histeq()
直方图均衡化是一种用于改善图像对比度的常见技术。它通过重新分布图像的灰度级别，使得整个灰度范围内的值都能得到充分利用，从而增强了图像的细节和对比度。这个技术在许多图像处理应用中都有着重要的作用，以下是一些具体的应用场景：

医学图像: 在医学图像领域，直方图均衡化被广泛应用于X光片、CT扫描、核磁共振图像等的增强，在一定程度上可以帮助医生更准确地诊断疾病。

计算机视觉: 直方图均衡化常用于图像预处理阶段，可以提高图像的对比度，以便更好地进行特征提取或者目标检测。

增强视频效果: 直方图均衡化也可以被应用在视频处理中，以增强视频画面的质量，提高观看体验。

卫星图像处理: 对于卫星图像中由于光照条件等因素导致的对比度不足问题，直方图均衡化可以用来增强图像的细节，更好地展现地表特征。

数字摄影: 在数字摄影中，直方图均衡化可以用来修复受限动态范围（如过暗或过曝）的照片，使得图像更加真实和艺术化。

14、Kernel Filtering - 核滤波

14、1代码：

# 核滤波
#
# 这个例子展示了核滤波。import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QVGA)      # 设置摄像头输出大小为 QVGA (320x240)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率kernel_size = 1 # 3x3==1, 5x5==2, 7x7==3, etc.kernel = [-2, -1,  0, \-1,  1,  1, \0,  1,  2]while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 在图像的每个像素上运行核img.morph(kernel_size, kernel)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

15、Lens Correction - 畸变校正

这个例程展示了如何使用畸变矫正方法来修复图像失真问题。在二维码/条形码/矩形码检测时需要使用此方法。
增加下面的strength直到直线在视图中。 zoom是在对图像进行缩放的数值。默认值为1。

img = sensor.snapshot().lens_corr(strength = 1.8, zoom = 1.0)

16、Log Polar Mapping - 对数极坐标映射

16、1代码

# 对数极坐标映射示例
# 此示例显示使用对数极坐标变换重新投影图像。 对数极坐标图像是有用的，
# 因为旋转成为X方向上的平移，并且刻度的指数变化（x2，x4等）变为Y方向上的线性平移。import sensor, image, timesensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)  # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot().logpolar(reverse=False)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

16、2 应用

图像配准与校正:在图像配准中，通常需要处理图像之间的旋转和尺度变化。通过将图像转换为线性极坐标空间，可以简化这些变换，从而更容易地实现图像的准确对齐和匹配。
圆形目标检测:在某些情况下，需要检测图像中的圆形目标或者进行圆形边界的分析。线性极坐标变换能够将圆形或部分圆形结构映射为直线，这样可以利用直线检测算法来检测圆形边界。
纹理分析与特征提取:对于某些纹理和结构，在极坐标空间中可能表现得更加明显或者更易于提取特征。例如，可以在极坐标空间中查找径向纹理特征或者分析环形结构。
图像增强与滤波:在某些图像增强和滤波任务中，线性极坐标变换可以用于调整图像的方向性特征或者去除特定的几何畸变。
医学图像处理:在医学图像中，例如超声波图像，可能需要对旋转和比例变换进行处理。线性极坐标变换可以用来简化这些变换，以便更准确地分析和处理图像数据。
传感器数据处理:对于一些传感器数据，例如雷达数据或者声纳数据，线性极坐标变换可以用来处理和分析物体的径向分布或者运动特性。

17、Log Polar Mapping - 对数极坐标映射

在给定的代码示例中，展示了如何使用对数极坐标变换（log-polar transformation）重新投影图像。与线性极坐标变换相比，对数极坐标变换有几个显著的区别和优势：变换形式：线性极坐标变换将原始图像中的像素从笛卡尔坐标系转换到极坐标系。在极坐标系中，角度（θ）和半径（r）代表了像素在图像中的位置。
对数极坐标变换则进一步转换，通过将半径和角度映射到对数域，实现了一种非线性变换。这种变换特别适合于处理图像中的周期性特征，例如纹理、边缘等，可以将旋转和缩放操作转化为平移操作。
优势：旋转不变性：对数极坐标变换可以使得图像在旋转时不发生变化，因为旋转在对数极坐标下变为平移。
尺度不变性：对数极坐标变换允许在尺度变化时保持特征的稳定性，因为尺度变化在对数极坐标下也表现为平移。
特征提取：对于某些图像处理任务，例如特征匹配或物体识别，对数极坐标变换可以增强对特定特征的感知和提取，因为它放大了低频信息（例如边缘和纹理）并抑制了高频信息（例如噪声）。
实现：在给定的代码中，使用了 sensor.snapshot().logpolar(reverse=False) 函数来获取对数极坐标变换后的图像。其中 reverse=False 表示不反转变换，即进行正向的对数极坐标变换。
这种变换可以在计算机视觉领域中用于各种任务，包括特征提取、目标检测和图像配准等。

17、1 代码

# 对数极坐标映射示例
# 此示例显示使用对数极坐标变换重新投影图像。 对数极坐标图像是有用的，
# 因为旋转成为X方向上的平移，并且刻度的指数变化（x2，x4等）变为Y方向上的线性平移。import sensor, image, timesensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)  # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot().logpolar(reverse=False)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

18 Mean Filter - 均值滤波

# 均值滤波例程
#
# 这个例子展示了均值滤波。均值滤波是NxN邻域的标准均值滤波。
# 均值滤波通过模糊所有内容来消除图像中的噪点。
# 但是，这是最快的内核过滤器操作import sensor, image, timesensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)  # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# The only argument is the kernel size. N coresponds to a ((N*2)+1)^2# kernel size. E.g. 1 == 3x3 kernel, 2 == 5x5 kernel, etc. Note: You# shouldn't ever need to use a value bigger than 2.# 唯一的参数是内核大小。N对a ((N*2)+1)^2的核大小有响应。# 例如:1 == 3x3内核，2 == 5x5内核，等等。# 注意:不应该使用大于2的值。img.mean(1)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

19、Midpoint Adaptive Threshold Filter - 中点自适应阈值滤波

19、1 代码

# 中点值自适应阈值滤波示例。
# 此示例显示了使用自适应阈值处理的中点滤波。 当midpoint(threshold=True) 时，
# midpoint()方法通过比较像素周围的像素的中值减去偏移量来自适应阈值图像。import sensor, image, timesensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QQVGA)  # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 第一个参数是内核大小。N对应于((N * 2)+1)^ 2内核大小。 # 例如。 1 == 3x3内核，2 == 5x5内核等。# 注意：您不应该使用大于2的值。# “bias”参数允许您在最小和最大混合之间进行选择。 0.5 ==中点过滤器，0.0 ==最小过滤器，# 1.0 ==最大过滤器。请注意，最小滤波器会使图像变暗，而最大滤波器会使图像变亮。img.midpoint(1, bias=0.5, threshold=True, offset=5, invert=True)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

20 、Negative - 像素值反转

# 像素值反转例程
#
# 此示例显示像素值反转图像。
# 这不是一个特别有用的方法，但它偶尔会派上用场。import sensor, image, timesensor.reset()                      # 复位并初始化摄像头
sensor.set_pixformat(sensor.RGB565) # 设置摄像头输出格式为 RGB565（也可以是GRAYSCALE）
sensor.set_framesize(sensor.QVGA)   # 设置摄像头输出大小为 QVGA (320x240)
sensor.skip_frames(time = 2000)     # 跳过2000帧
clock = time.clock()                # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot().negate()print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

21 Sharpen Filter - 图像锐化

# 图像锐化例程：
#
# 这个例子演示了如何使用morph变换来锐化图像import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率while(True):clock.tick()                    # 更新计算帧率的clockimg = sensor.snapshot()         # 拍照，获取一张图像# 在图像的每个像素上运行核img.laplacian(1, sharpen=True)print(clock.fps()) # 注意: 当连接电脑后，CanMV会变成一半的速度。当不连接电脑，帧率会增加。

21、Edge detection - 边缘检测

# 这个示例展示了使用 Canny 算法进行边缘检测import sensor, image, timesensor.reset()                          # 复位并初始化摄像头
sensor.set_pixformat(sensor.GRAYSCALE)  # 设置摄像头输出格式为 GRAYSCALE（也可以是RGB565）
sensor.set_framesize(sensor.QQVGA)      # 设置摄像头输出大小为 QQVGA (160x120)
sensor.skip_frames(time = 2000)         # 跳过2000帧
clock = time.clock()                    # 创建一个clock对象，用来计算帧率while(True):clock.tick()                        # 更新计算帧率的clockimg = sensor.snapshot()             # 拍照，获取一张图像# 使用 Canny 边缘检测器（稍慢）img.find_edges(image.EDGE_CANNY, threshold=(50, 80))# 使用 simpler 边缘检测器 （更快）#img.find_edges(image.EDGE_SIMPLE, threshold=(100, 255))print(clock.fps()) # 打印帧率

22 、Find Lines - 直线检测

# 识别直线例程
#
# 这个例子展示了如何在图像中查找线条。对于在图像中找到的每个线对象，
# 都会返回一个包含线条旋转的线对象。# 注意：线条检测是通过使用霍夫变换完成的：
# http://en.wikipedia.org/wiki/Hough_transform
# 请阅读以上关于“theta”和“rho”的更多信息。# find_lines（）找到无限长度的线。使用find_line_segments（）
# 来查找非无限线。enable_lens_corr = False # 打开以获得更直的线条…import sensor, image, timesensor.reset()
sensor.set_pixformat(sensor.RGB565) # 灰度更快
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()# 所有的线对象都有一个`theta（）`方法来获取它们的旋转角度。
# 您可以根据旋转角度来过滤线条。min_degree = 0
max_degree = 179# 所有线段都有 `x1()`, `y1()`, `x2()`, and `y2()` 方法来获得他们的终点
# 一个 `line()` 方法来获得所有上述的四个元组值，可用于 `draw_line()`.while(True):clock.tick()img = sensor.snapshot()if enable_lens_corr: img.lens_corr(1.8) # for 2.8mm lens...# `threshold` controls how many lines in the image are found. Only lines with# edge difference magnitude sums greater than `threshold` are detected...# `threshold`控制从霍夫变换中监测到的直线。只返回大于或等于阈值的# 直线。应用程序的阈值正确值取决于图像。注意：一条直线的大小是组成# 直线所有索贝尔滤波像素大小的总和。# `theta_margin`和`rho_margin`控件合并相似的直线。如果两直线的# theta和ρ值差异小于边际，则它们合并。for l in img.find_lines(threshold = 1000, theta_margin = 25, rho_margin = 25):if (min_degree <= l.theta()) and (l.theta() <= max_degree):img.draw_line(l.line(), color = (255, 0, 0))# print(l)print("FPS %f" % clock.fps())# About negative rho values:
# 关于负rho值:
#
# A [theta+0:-rho] tuple is the same as [theta+180:+rho].
# A [theta+0:-rho]元组与[theta+180:+rho]相同。

for l in img.find_lines(threshold=1000, theta_margin=25, rho_margin=25):这行代码使用了一个名为img的对象（可能是图像对象），调用了find_lines方法来查找图像中的直线。
threshold参数设定了直线检测的阈值，可能是指边缘检测后的强度阈值，只有高于这个阈值的像素点才被认为是直线的一部分。
theta_margin和rho_margin参数用于控制直线检测的精度和灵敏度。
if (min_degree <= l.theta()) and (l.theta() <= max_degree):对于每条检测到的直线l，这行代码检查其角度theta()是否在指定的最小角度min_degree和最大角度max_degree之间。
这个条件用于过滤掉一些不需要的直线，只保留在特定角度范围内的直线。
img.draw_line(l.line(), color=(255, 0, 0))如果直线l符合角度范围的条件，那么就调用img对象的draw_line方法来在图像上绘制这条直线。
l.line()返回直线的参数表示（通常是rho和theta），这些参数用于在图像上绘制一条直线。
color=(255, 0, 0)指定了绘制直线时的颜色，这里是红色。

23 、Object tracking with keypoints - 特征点检测

# 利用特征点检测特定物体例程。
# 向相机显示一个对象，然后运行该脚本。 一组关键点将被提取一次，然后
# 在以下帧中进行跟踪。 如果您想要一组新的关键点，请重新运行该脚本。
# 注意：请参阅文档以调整find_keypoints和match_keypoints。import sensor, time, imagesensor.reset() # 复位并初始化摄像头# 设置摄像头
sensor.set_contrast(3)
sensor.set_gainceiling(16)
sensor.set_framesize(sensor.VGA)
sensor.set_windowing((320, 240))
sensor.set_pixformat(sensor.GRAYSCALE)sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False, value=100)def draw_keypoints(img, kpts):if kpts:print(kpts)img.draw_keypoints(kpts)img = sensor.snapshot()time.sleep_ms(1000)kpts1 = None
#kpts1保存目标物体的特征，可以从文件导入特征，但是不建议这么做。
#kpts1 = image.load_descriptor("/desc.orb")
#img = sensor.snapshot()
#draw_keypoints(img, kpts1)clock = time.clock()
while (True):clock.tick()img = sensor.snapshot()if (kpts1 == None):#如果是刚开始运行程序，提取最开始的图像作为目标物体特征，kpts1保存目标物体的特征#默认会匹配目标特征的多种比例大小，而不仅仅是保存目标特征时的大小，比模版匹配灵活。kpts1 = img.find_keypoints(max_keypoints=150, threshold=10, scale_factor=1.2)draw_keypoints(img, kpts1)else:# 当与最开始的目标特征进行匹配时，默认设置normalized=True，只匹配目标特征的一种大小。kpts2 = img.find_keypoints(max_keypoints=150, threshold=10, normalized=True)if (kpts2):match = image.match_descriptor(kpts1, kpts2, threshold=85)if (match.count()>10):#在匹配到的目标特征中心画十字和矩形框。img.draw_rectangle(match.rect())img.draw_cross(match.cx(), match.cy(), size=10)print(kpts2, "matched:%d dt:%d"%(match.count(), match.theta()))# 不建议draw_keypoints画出特征关键点。# 注意:如果你想绘制关键点，取消注释#img.draw_keypoints(kpts2, size=KEYPOINTS_SIZE, matched=True)img.draw_string(0, 0, "FPS:%.2f"%(clock.fps())) #打印帧率。

23、Fast Linear Regression - 快速线性回归（巡线）

# 快速线性回归（巡线）例程
#
# 这个例子展示了如何在CanMV Cam上使用get_regression（）方法来获得
# ROI的线性回归。 使用这种方法，你可以轻松地建立一个机器人，它可以
# 跟踪所有指向相同的总方向但实际上没有连接的线。 在线路上使用
# find_blobs（），以便更好地过滤选项和控制。
#
# 这被称为快速线性回归，因为我们使用最小二乘法来拟合线。然而，这种方法
# 对于任何具有很多（或者甚至是任何）异常点的图像都是不好的，
# 这会破坏线条拟合.#设置阈值，（0，100）检测黑色线
THRESHOLD = (0, 100)# 首先执行二进制操作，以便您可以看到正在运行的线性回归...虽然可能会降低FPS。
BINARY_VISIBLE = Trueimport sensor, image, timesensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()while(True):clock.tick()img = sensor.snapshot().binary([THRESHOLD]) if BINARY_VISIBLE else sensor.snapshot()# 函数返回回归后的线段对象line，有x1(), y1(), x2(), y2(), length(), theta(), rho(), magnitude()参数。# x1 y1 x2 y2分别代表线段的两个顶点坐标，length是线段长度，theta是线段的角度。# magnitude表示线性回归的效果，它是（0，+∞）范围内的一个数字，其中0代表一个圆。如果场景线性回归的越好，这个值越大。line = img.get_regression([(255,255) if BINARY_VISIBLE else THRESHOLD])if (line): img.draw_line(line.line(), color = 127)print("FPS %f, mag = %s" % (clock.fps(), str(line.magnitude()) if (line) else "N/A"))# 关于负rho值:
#
# A [theta+0:-rho] tuple is the same as [theta+180:+rho].
# A [theta+0:-rho]元组与[theta+180:+rho]相同

24、Automatic Grayscale Color Tracking - 自动灰度颜色追踪

# 自动灰度颜色追踪例程
#
# 这个例子展示了使用CanMV的单色自动灰度色彩跟踪。import sensor, image, time
print("Letting auto algorithms run. Don't put anything in front of the camera!")sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False) # 颜色跟踪必须自动增益
sensor.set_auto_whitebal(False) # 颜色跟踪必须关闭白平衡
clock = time.clock()# Capture the color thresholds for whatever was in the center of the image.
r = [(320//2)-(50//2), (240//2)-(50//2), 50, 50] # 50x50 center of QVGA.print("Auto algorithms done. Hold the object you want to track in front of the camera in the box.")
print("MAKE SURE THE COLOR OF THE OBJECT YOU WANT TO TRACK IS FULLY ENCLOSED BY THE BOX!")
for i in range(60):img = sensor.snapshot()img.draw_rectangle(r)print("Learning thresholds...")
threshold = [128, 128] # Middle grayscale values. 中间灰度值。
for i in range(60):img = sensor.snapshot()hist = img.get_histogram(roi=r)lo = hist.get_percentile(0.01) # 获取1％范围的直方图的CDF（根据需要调整）！hi = hist.get_percentile(0.99) # 获取99％范围的直方图的CDF（根据需要调整）！# 平均百分位值。threshold[0] = (threshold[0] + lo.value()) // 2threshold[1] = (threshold[1] + hi.value()) // 2for blob in img.find_blobs([threshold], pixels_threshold=100, area_threshold=100, merge=True, margin=10):img.draw_rectangle(blob.rect())img.draw_cross(blob.cx(), blob.cy())img.draw_rectangle(r)print("Thresholds learned...")
print("Tracking colors...")while(True):clock.tick()img = sensor.snapshot()for blob in img.find_blobs([threshold], pixels_threshold=100, area_threshold=100, merge=True, margin=10):img.draw_rectangle(blob.rect())img.draw_cross(blob.cx(), blob.cy())print(clock.fps())