znzpi 用户手册

$ cat /etc/init.d/S99mpp
/root/auto_run.sh

/*znzpi的主程序*/
....
/memdisk/setup/bin/socket_httpd
....

$ udhcpc -i bond0

# AprilTags Example
#
# This example shows the power of the OpenMV Cam to detect April Tags
# on the OpenMV Cam M7. The M4 versions cannot detect April Tags.

import sensor, image, time, math

sensor.reset()
sensor.set_pixformat(sensor.GRAYSCALE)
sensor.set_framesize(sensor.VGA) # we run out of memory if the resolution is much bigger...
sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False)  # must turn this off to prevent image washout...
sensor.set_auto_whitebal(False)  # must turn this off to prevent image washout...
clock = time.clock()

# Note! Unlike find_qrcodes the find_apriltags method does not need lens correction on the image to work.

# The apriltag code supports up to 6 tag families which can be processed at the same time.
# Returned tag objects will have their tag family and id within the tag family.

tag_families = 0
tag_families |= image.TAG16H5 # comment out to disable this family
tag_families |= image.TAG25H7 # comment out to disable this family
tag_families |= image.TAG25H9 # comment out to disable this family
tag_families |= image.TAG36H10 # comment out to disable this family
tag_families |= image.TAG36H11 # comment out to disable this family (default family)
tag_families |= image.ARTOOLKIT # comment out to disable this family

# What's the difference between tag families? Well, for example, the TAG16H5 family is effectively
# a 4x4 square tag. So, this means it can be seen at a longer distance than a TAG36H11 tag which
# is a 6x6 square tag. However, the lower H value (H5 versus H11) means that the false positve
# rate for the 4x4 tag is much, much, much, higher than the 6x6 tag. So, unless you have a
# reason to use the other tags families just use TAG36H11 which is the default family.

def family_name(tag):
    if(tag.family() == image.TAG16H5):
        return "TAG16H5"
    if(tag.family() == image.TAG25H7):
        return "TAG25H7"
    if(tag.family() == image.TAG25H9):
        return "TAG25H9"
    if(tag.family() == image.TAG36H10):
        return "TAG36H10"
    if(tag.family() == image.TAG36H11):
        return "TAG36H11"
    if(tag.family() == image.ARTOOLKIT):
        return "ARTOOLKIT"

def loop():
    clock.tick()
    img = sensor.snapshot()
    for tag in img.find_apriltags(families=tag_families): # defaults to TAG36H11 without "families".
        img.draw_rectangle(tag.rect(), color = (255, 0, 0))
        img.draw_cross(tag.cx(), tag.cy(), color = (0, 255, 0))
        print_args = (family_name(tag), tag.id(), (180 * tag.rotation()) / math.pi)
        print("Tag Family %s, Tag ID %d, rotation %f (degrees)" % print_args)
    print(clock.fps())

image.draw_line(x0, y0, x1, y1[, color[, thickness= 1]])

绘制一条从 (x0, y0) 到 (x1, y1 ) 的直线。

x0、y0、x1、y1: 起始点坐标和终点坐标，可以单独使用 x0、y0、x1、y1,也可以使用元组 (x0, y0, x1, y1)

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

thickness: 控制线条的粗细(以像素为单位)。

返回图像对象

image.draw_rectangle(x, y, w, h[, color[, [thickness =1, fill = False]]])

绘制一个矩形。

x,y,w,h: 矩形的左上角坐标和宽度高度，可以单独使用 x,y,w,h,也可以使用元组 (x, y, w, h)。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

thickness: 控制线条的粗细(以像素为单位)。

fill: 是否绘制实心矩形,绘制实心矩形,可以将Fill 设置为 True 。

返回图像对象

image.draw_circle(x,y,radius[,color[,thickness=1[,fill=False]]])

绘制一个圆圈。

 x,y,radious: 圆心坐标和圆半径。可以单独使用 x,y,radious,也可以使用元组(x,y,radius)。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

thickness: 控制边缘的thickness(以像素为单位)。

fill: 如果要绘制实心圆形,可以将Fill 设置为 True

返回图像对象。

image.draw_ellipse(cx, cy, rx, ry, rotation[, color[, thickness= 1[, fill = False]]])

绘制一个椭圆。

cx,cy,rx,ry: 椭圆的圆心。可以使用 cx,cy,rx,ry 和rotation(以度为单位),也可以使用元组(cx,yc,rx,ry,rotation)。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

thickness: 控制边缘的thickness(以像素为单位)。

fill: 如果要绘制实心椭圆,可以将Fill设置为 True。

返回图像对象。

image.draw_string(x, y, text[, color[, scale=1[, x_spacing=0[, y_spacing=0[, mono_spaceTrue[, char_rotation=0[, char_hmirror=False[, char_vflip=False[, string_rotation=0[, string_hmirror=False[, string_vflip=False]]]]]]]]]]])

在位置 (x, y) 绘制文本。

x,y: 起始坐标，可以单独使用 x、y 或使用元组 (x, y)。

text: 是要输出的字符串。并将行尾将光标移动到下一行。\n\r\r\n

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

scale: 缩放系数，可以增加以放大或缩小文本的大小。可以使用大于 0 的整数或浮点值。

x_spacing: 可以在 cahracters 之间添加(如果为正)或减去(如果为负)x 像素。

y_spacing: 可以在 cahracters 之间添加(如果为正)或减去(如果为负)y 像素(对于多行文本)。

mono_space: 默认值为 True,强制文本间隔固定。设置 False 以获得非固定宽度字符间距。

char_rotation 可以用0,90,180,270来旋转字符串中的每个字符。

char_hmirror: 如果设置为 True,将水平镜像字符串中的所有字符。

char_vflip: 如果设置为 True,将垂直翻转字符串中的所有字符。

string_rotation: 可以用0、90、180、270来旋转整个字符串。

string_hmirror: 如果设置为 True 将水平镜像整个字符串。

string_vflip: 如果设置为 True 将垂直翻转整个字符串。

返回图像对象。

image.draw_cross(x, y[, color[, size= 5[, thickness = 1]]])

在位置 x, y 处绘制一个十字。

x,y: 中心坐标，可以使用 x、y 或使用元组 (x, y)。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

size: 控制十字线的大小。

thickness: 控制边缘的thickness(以像素为单位)。

返回图像对象。

image.draw_arrow(x0, y0, x1, y1[, color[, thickness= 1]])

上绘制一个从 (x0, y0) 到 (x1, y1) 的箭头。

x0,y0,x1,y1: 箭头的起始坐标和结束坐标，可以使用 x0,y0,x1,y1,也可以使用元组 (x0, y0, x1, y1)。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

thickness: 控制线条的粗细(以像素为单位)。

返回图像对象。

image.draw_edges(image,corners[,color[,size= 0[,thickness= 1[,fill= False]]]])

corners: 绘制blob.corners 等方法返回的角点构成的边缘线。Coners 是包含坐标 x,y 元组的四值元组。例如 [(x1,y1),(x2,y2),(x3,y3),(x4,y4)]。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

size: 如果大于 0 会将角点绘制为以size为半径的圆点 。

thickness: 控制线条的粗细(以像素为单位)。

fill: 需要绘制实心时圆角时,将 Fill 设置为 True。

返回图像对象。

image.draw_image(image, x, y[, x_scale=1.0[, y_scale=1.0[, roi=None[, rgb_channel=-1[, alpha=256[, hint=0[, x_size=None[, y_size=None]]]]]]]]]])

在位置 x, y 绘制图像。

x,y: 图像左上角坐标，可以使用 x、y 或元组 (x, y)作为图像左上角位置的坐标。此方法自动处理将传递的图像渲染为目标图像的正确像素格式,同时还无缝处理剪切。

x_scale: 控制绘制的图像在 x 方向(浮点型)上的缩放。如果此值为负数,则图像将水平翻转。

y_scale: 控制绘制的图像在 y 方向(浮点型)上的缩放。如果此值为负数,则图像将垂直翻转。

roi: 是要绘制的源图像的感兴趣区域矩形元组 (x, y, w, h)。这允许您仅提取ROI中的像素,以缩放和绘制目标图像。

rgb_channel: 从彩色图像(如果传递)中提取并渲染到目标图像的 RGB 通道(0=R、G=1、B=2)。例如,如果rgb_channel=1 这将提取源图像的绿色通道,并在目标图像上以灰度绘制该通道。

alpha: 控制要将源图像的多少内容混合到目标图像中。值为 256 将绘制不透明的源图像,而值小于 256 将在源图像和目标图像之间生成混合。0 表示不对目标映像进行任何修改。

hint: 可以是标志的逻辑 OR：

    image.AREA：在缩小缩放时使用区域缩放,而不是使用最近邻的默认值。
    image.BILINER：使用双线性缩放与最近邻缩放的默认值。
    image.BICUBIC：使用双三次缩放与默认的最近邻缩放。
    image.CENTER：使正在绘制的图像图像居中 (x, y)。
    image.EXTRACT_RGB_CHANNEL_FIRST：在缩放之前执行rgb_channel提取。
    image.APPLY_COLOR_PALETTE_FIRST：在缩放之前应用调色板。
    image.BLACK_BACKGROUND：设目标图像为黑色。这加快了绘图速度。

x_size: 指定要绘制的图像的大小。如果未指定或未指定,则在内部将设置为等于x_scale 以保持纵横比。

y_size: 指定要绘制的图像的大小。如果未指定或未指定,则在内部将设置为等于y_scale 以保持纵横比。

返回图像对象。

import image
import sensor

sensor.reset()
img = sensor.snapshot()

def loop():
    img = sensor.snapshot()
    img.draw_image(img,(0,0),x_scale=0.5,y_scale=0.5)
    print('ok')

image.draw_keypoints(keypoints[,color[,size = 10[,thickness = 1[,fill = False]]]])

绘制关键点。

keypoints: 递包含 (x, y, rotation_angle_in_degrees) 的三个值元组的列表,以重用此方法绘制关键点字形,这些标志形是具有指向特定方向的线的圆环。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

size: 控制关键点的大小。

thickness: 控制线条的粗细(以像素为单位)。

fill: 如果需要填充,设置为 True 。

返回图像对象。

image.Image(path)

读取 jpeg文件，并存入image中，可用于后面的处理，或作为其他算法的输入。

path : 图片路径

import image

img = image.Image('dog.jpg')

img.draw_image(img,(0,0))

image.flood_fill(x, y[, seed_threshold=0.05[, floating_threshold=0.05[, color[, Invert=False[, clear_background=False[, Mask=None]]]]]])

从位置 x, y 开始的图像区域做漫水填充。

x,y: 起始位置，可以使用 x、y 或元组 (x, y)。

seed_threshold: 控制田中区域中的任何像素与原始起始像素的阈值。

floating_threshold: 控制填充区域中的任何像素与任何相邻像素的阈值。

color: 可以使用 RGB888值,或 RGB888 元组。默认为白色。

invert: 如果传递为 True 以重新着色泛洪fill连接区域之外的所有内容。

clear_background: 将填充点重新着色的其余像素。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。在满水填充时,仅使用蒙版中设置的像素。

返回图像对象。

image.mask_rectange([x, y, w, h])

将图像的矩形部分归零。

如果未提供任何参数,则此方法将图像的中心归零。

返回图像对象。

image.mask_circle([x, y, radius])

将图像的圆形部分归零。

如果未提供任何参数,则此方法将图像的中心归零。

返回图像对象。

image.mask_ellipse([x、y、radius_x、radius_y、rotation_angle_in_degrees])

将图像的椭圆形部分归零。

如果未提供任何参数,则此方法将图像的中心归零。

返回图像对象。

image.binary(thresholds[,invert=False[,zero=False[,mask=None[,to_bitmap=False[,copy=False]]]]])

将图像中的所有像素设置二值化,具体取决于像素是否在阈值列表中的阈值范围内。

thresholds: 对于灰度图像,每个元组需要包含两个值 - 最小灰度值和最大灰度值。将仅考虑介于这些阈值之间的像素区域。
对于彩色图像,每个元组需要有六个值(l_lo、l_hi、a_lo、a_hi、b_lo、b_hi) - 分别是 LAB L、A 和 B 通道的最小值和最大值。为了便于使用,此功能将自动修复交换的最小值和最大值。此外,如果元组大于六个值,则忽略其余部分。相反,如果元组太短,则其余阈值处于最大范围。[(lo, hi), (lo, hi), ..., (lo, hi)]

注意

要获取要跟踪的对象的阈值,只需在 IDE 帧缓冲区中选择要跟踪的对象上选择(单击并拖动)即可。然后,直方图将更新为仅位于该区域中。
然后只需记下颜色分布在每个直方图通道中开始和下降的位置。这些将是 您的低值和高值。最好手动确定阈值,而不是使用上限和下四分位数统计信息,因为它们太紧了。

还可以通过在 IDE 中使用阈值设置功能,选择阈值来确定颜色阈值。工具->阈值分析

invert: 反转阈值操作,以便匹配某些已知color边界内的像素,而不是匹配已知color边界之外的像素。

zero: 设置为 True 可改为零阈值像素,并使阈值列表中未受影响的像素保持不变。

mask: 像素级蒙版图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

to_bitmap: 将图像数据转换为二进制位图图像,其中每个像素以 1 位存储。对于非常小的图像,新的位图图像可能不适合原始图像的内部,需要使用copy扩充

copy: 如果 True 在堆上创建二值化映像的副本,而不是修改源映像。

注意

位图图像类似于只有两个像素值(0 和 1)的灰度图像。此外,位图图像被打包,使得它们每像素仅存储1位,使它们非常小。图像库允许在传感器的所有位置使用位图图像,灰度图。可以使用彩色图像。但是,在位图图像上应用许多操作没有任何意义,因为位图图像只有 2 个值。建议在操作中使用位图图像作为值。最后,位图图像像素值 0 和 1 在应用于图像处理时被解释为黑白。与灰度图或彩色图像,进行运算是,会自动转换。

返回图像对象。

image.invert()

二进制反转图像中的所有像素值。

返回图像对象。

image.b_and(image[,mask = None])

将图像与另一个图像做逻辑与。

image: 可以是图像对象。

mask: 像素级蒙版图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.b_nand(image[,mask = None])

与另外图像做取反后做逻辑与操作。

image: 另外一个需要操作的图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.b_or(image[,mask = None])

另一个图像做逻辑或操作。

image: 另外一个需要操作的图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.b_nor(image[,mask = None])

与另一个图像做取反和或操作。

image: 需要操作的图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.b_xor(image[,mask = None])

与另一个图像做异或操作。

image: 另外一个进行操作的图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.b_xnor(image[,mask = None])

另一个图像做取反异或操作。

image: 另外一个操作的图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.erode(size[,threshold[,mask = None]])

对图像做腐蚀操作。

size: 滤波器大小，此方法的工作原理是将 ((size*2)+1)x((size*2)+1) 像素的内核卷积到图像上,如果相邻像素集集之和不大于threshold,则将内核的中心像素归零。

threshold: 如果未设置阈值,则此方法的工作方式类似于标准侵蚀方法。如果设置了 ,则可以指定侵蚀为仅侵蚀像素,例如,在其周围设置小于 2 像素且阈值为 2 的像素。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.dilate(size[,threshold,[mask = None]])

对图像做膨胀操作。

size: 滤波器的大小，此方法的工作原理是将 ((size*2)+1)x((size*2)+1) 像素的内核卷积到图像上,如果相邻像素集的总和大于 ,则设置内核的中心像素。

threshold: 如果未设置阈值,则此方法的工作方式类似于标准扩张方法。如果设置了 ,则可以将“扩张”指定为仅扩张像素,例如,围绕这些像素设置的像素超过 2,阈值为 2。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.open(size[,threshold[,mask = None]])

按顺序对图像执行侵蚀和膨胀。

mask: 素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.close(size[,threshold[,mask = None]])

按顺序对图像执行膨胀和侵蚀。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.top_hat(size[,threshold[,mask = None]])

返回图像和 image.open 图像的图像差异。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

image.black_hat(size[,threshold,mask = None]])

返回图像和 image.close 图像的图像差异。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

image.gamma_corr([gamma=1.0,[contrast=1.0,[brightness=0.0])

快速更改图像灰度系数、对比度和亮度。请使用此方法代替image.mul 或 image.div,它们用于混合以调整像素值。

gamma值大于 1.0 会使图像以非线性方式变暗,而小于 1.0 会使图像更亮。通过将所有像素color通道缩放到 [0：1) 之间,然后在缩小之前对所有像素进行重新映射,将 gamma 值应用于图像。pow(pixel, 1/gamma)

contrast值大于 1.0 会使图像以线性方式变亮,而小于 1.0 会使图像变暗。通过将所有像素color通道缩放到 [0：1) 之间,然后在缩小之前对所有像素进行重新映射,将对比度值应用于图像。pixel * contrast

brightness值大于 0.0 会使图像以恒定的方式变亮,而小于 0.0 会使图像变暗。通过将所有像素color通道缩放到 [0：1) 之间,然后在缩小之前对所有像素进行重新映射,将亮度值应用于图像。pixel + brightness

返回图像对象。

image.negate()

数字反转图像中的所有像素值。例如,对于灰度图像,此方法将所有像素从 更改为 。pixel255 - pixel

返回图像对象。

image.replace(image[, hmirror=False[, vflip=False[, transpose=False[, mask=None]]]])

将图像对象中的所有像素替换为新图像。

image: 可以是另一个图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

hmirror: 设置为 True 可水平镜像替换图像。

vflip: 设置为 True 可垂直翻转替换图像。

transpose: 设置为 True 可沿对角线翻转图像(如果图像不是正方形,则会更改图像的宽度/高度)。

如果要将图像旋转 90 度的倍数,请执行以下操作：

vflip=False, hmirror=False, transpose=False -> 0 度旋转
vflip=True, hmirror=False, transpose=True -> 90 度旋转
vflip=True, hmirror=True, 转置=False -> 180 度旋转
vflip=False, hmirror=True, transpose=True -> 270 度旋转
注意

如果不传递,此方法将对要替换的基础映像进行操作,方法是应用 、 和 选项来旋转图像。例如,如果你想做,你只需要做。imagehmirrorvfliptransposeimg.replace(img, etc...)img.replace(etc..)

mask是另一个用作操作的像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。请注意,蒙版是在 hmirror/vflip/转置之前应用于图像的,因此蒙版的宽度/高度应与初始未修改图像的宽度/高度相同。

返回图像对象。

image.assign(image, hmirror=False, vflip=False, transpose=False, mask=None[[[[]]]])

image.replace 的别名。

image.set(image, hmirror=False, vflip=False, transpose=False, mask=None[[[[]]]])

image.replace 的别名。

image.add(image[,maske = None[])

将图像像素添加到此图像中。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.sub(image[,invert=False[,maske=None]])

将图像像素逐像素减去。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

invert: 设置为 True 可将减法运算从 反转为 。reversethis_image-imageimage-this_image

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.mul(image[,invert=False[,mask=None]])

将两个图像按像素相乘。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

invert: 设置为 True 可将乘法运算从 更改为 。特别是,这可以使图像变亮而不是变暗(例如,乘法与刻录操作)。inverta*b1/((1/a)*(1/b))

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

注意

此方法用于图像混合,不能将图像中的像素乘以标量,如需要乘以标量，需要使用image.gamma_corr。

image.div(image[,invert=False[,mod=False[,mask=None]]])

将此图像除以另一个图像。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

invert: 设置为 True 可将除法方向从 更改为 。

mod: 设置为 True 可将除法运算更改为模运算。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

注意

此方法用于图像混合,不能将图像中的像素乘以标量,如需要乘以标量，需要使用image.gamma_corr。

image.min(image[,mask = None])

按像素返回两个图像的最小图像。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.max(image[,mask = None])

按像素返回两个图像的最大图像。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.difference(image[,mask = None])

返回两个图像之间的绝对差分图像(例如||a-b||)。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.blend(image[,alpha=128[,mask=None]])

Alpha 将两个图像相互混合。

image: 可以是图像对象、未压缩图像文件的路径(bmp/pgm/ppm)或标量值。如果是标量值,则该值可以是 RGB888 元组或基础像素值(例如,灰度图像为 8 位灰度,RGB 图像为 RGB565 值)。

alpha: 控制要将其他图像的多少内容混合到此图像中。 应为介于 0 和 256 之间的整数值。接近零的值会将更多其他图像混合到此图像中,而接近 256 的值则相反。alpha

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.histeq([adaptive =False[,clip_limit=-1[,mask =None]]])

对图像运行直方图均衡算法。直方图均衡可归一化图像中的对比度和亮度。

adaptive: 为 True,则将在图像上运行自适应直方图均衡方法,该方法通常比非自适应直方图限定结果更好,但运行时间更长。

clip_limit: 提供了一种限制自适应直方图限定的对比度的方法。为此使用一个小值(如 10),以生成良好的直方图均衡对比度有限图像。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.mean(size, [threshold=False, [offset=0, [invert=False, [mask=None]]]]])

使用滤波器进行标准均值模糊。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

threshold: 在滤波器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。设置为反转生成的二进制图像输出。threshold=Trueoffsetinvert

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.median(size[,perecentile = 0.5[,threshold = False[,offset = 0[,invert = False[,mask = None]]]]])

对图像运行中值滤波器。中值滤波器是平滑表面同时保留边缘的最佳滤波器。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

percentile: 控制内核中使用的值的百分位数。默认情况下,每个像素都替换为其相邻像素的第 50 个百分位(中心)。对于最小筛选器,可以将其设置为 0,对于下四分位数筛选器,可以将其设置为 0.25,对于上四分位数筛选器,可以将其设置为 0.75,对于最大筛选器,可以将其设置为 1.0。

threshold: 在滤波器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。设置为反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.mode(size[, threshold=False[,offset=0[,invert=False[, maske=None]]]]])

通过将每个像素替换为其相邻像素的模式,对图像运行模式滤波。此方法在灰度图像上效果很好。然而,在RGB图像上,由于操作的非线性性质,它会在边缘上产生很多伪像。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

threshold: 在过滤器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。设置为反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.midpoint(size[,bias =0.5[,threshold=False[,offset=0[,invert=False[,mask=None]]]]])

对图像运行中点滤镜。此滤镜查找图像中每个像素邻域的中点 ((最大值-最小值)/2)。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

bias: 控制最小/最大混合。0 仅用于最小滤波,1.0 仅用于最大滤波。通过使用,您可以最小化/最大过滤图像。

threshold: 在滤波器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。设置为反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.morph(size, kernel[, mul[, add=0[, threshold=False[, offset=0[, invert=False[, mask=None]]]]]])

通过过滤器内核对图像进行卷积。这允许您对图像进行通用卷积。

size: 控制内核的大小,该内核必须是 ((size*2)+1)x((size*2)+1) 元素。

kernel: 是卷积图像的内核。它可以是元组或整数值列表。

mul: 是将卷积像素结果乘以的数字。如果未设置,则默认为一个值,该值将阻止卷积输出中的缩放。

add: 是要添加到每个卷积像素结果的值。

mul: 基本上允许您进行全局对比度调整,并允许您进行全局亮度调整。超出图像最小值和color通道最大值的像素将被剪切。add

threshold: 在滤波器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。

invert: 设置为反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.gaussian(size[, unsharp=False[, mul[, add=0[, threshold=False[, offset=0[, invert=False[, mask=None]]]]]]])

通过平滑的瓜西核对图像进行卷积。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

unsharp: 如果设置为 True,则此方法将执行不清晰的蒙版操作,而不是仅执行鸟祇滤波操作,从而提高边缘的图像清晰度。unsharp

mul 是将卷积像素结果乘以的数字。如果未设置,则默认为一个值,该值将阻止卷积输出中的缩放。

add: 是要添加到每个卷积像素结果的值。

mul: 基本上允许您进行全局对比度调整,并允许您进行全局亮度调整。超出图像最小值和color通道最大值的像素将被剪切。add

threshold: 在滤波器的输出上使用自适应阈值,则可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。

invert: 设置为反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.laplacian(size[,sharpen=False[,mul[,add=0[,threshold=False[,offset=0[,invett=False[,mask=None]]]]]]])

通过边缘检测拉普拉斯核对图像进行卷积。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

sharpen: 如果设置为 True,则此方法将反而锐化图像,而不是仅输出非阈值边缘检测图像。然后增加内核大小以增加图像清晰度。

mul: 是将卷积像素结果乘以的数字。如果未设置,则默认为一个值,该值将阻止卷积输出中的缩放。

add: 是要添加到每个卷积像素结果的值。

mul: 基本上允许您进行全局对比度调整,并允许您进行全局亮度调整。超出图像最小值和color通道最大值的像素将被剪切。add

threshold: 在滤波器的输出上使用自适应阈值,可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。

invert: 设置为True反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.bilateral(size[, color_sigma=0.1[, space_sigma=1[, threshold=False[, offset=0[, invert=False[, maske=None]]]]]])

通过双边滤镜对图像进行卷积。双边滤镜平滑图像,同时保持图像中的边缘。

size: 是内核大小。使用 1(3x3 内核)、2(5x5 内核)等。

color_sigma: 控制使用双边滤镜匹配color的紧密程度。增加此值可增加color模糊。

space_sigma: 控制像素在空间上彼此模糊的紧密程度。增加此值可增加像素模糊。

threshold: 在滤波器的输出上使用自适应阈值,则可以通过该阈值来启用图像的自适应阈值,该阈值将根据像素的亮度相对于周围像素内核的亮度将像素设置为1或零。负值将更多的像素设置为 1,因为您使该像素更加负值,而正值仅将最锐利的对比度变化设置为 1。

invert: 设置为True反转生成的二进制图像输出。

mask: 像素级蒙版的图像。蒙版应为仅具有黑色或白色像素的图像,并且应与正在操作的图像大小相同。仅修改蒙版中设置的像素。

返回图像对象。

image.linpolar([invert = False])

将图像从笛卡尔坐标重新投影到线性极坐标。

reverse: 设置为True以相反方向重新投影。

线性极性重投影将图像的旋转转换为 x 平移。

image.logpolar([invert = False])

从笛卡尔坐标重新投影和图像以记录极坐标。

reverse: 设置为True以相反方向重新投影。

对数极坐标重新投影将图像的旋转转换为 x 平移,缩放/缩放为 y 平移。

image.lens_corr([strength=1.8[,scale=1.0[,x_corr=0.0[,y_corr=0.0]]]])

执行镜头校正以取消鱼眼图像,因为镜头失真。

strength: 是一个浮标,定义了取消鱼眼图像的量。默认情况下尝试1.8 out,然后从那里增加或减少,直到图像看起来不错。

zoom: 是放大图像的量。默认为 1.0。

x_corr: 从中心偏移的浮点像素。可以是负数,也可以是阳性。

y_corr: 从中心偏移的浮点像素。可以是负数,也可以是阳性。

返回图像对象。

image.rotation_corr([x_rotation=0.0[, y_rotation=0.0[, z_rotation=0.0[, x_translation=0.0[, y_translation=0.0[, scale=1.0[, fov=60.0[, angle]]]]]]]])

通过对帧缓冲区执行 3D 旋转来更正图像中的透视问题。

x_rotation: 是帧缓冲区中图像绕 x 轴旋转的度数(即,这会上下旋转图像)。

y_rotation: 是帧缓冲区中图像围绕 y 轴旋转的度数(即,这会左右旋转图像)。

z_rotation: 是帧缓冲区中图像围绕 z 轴旋转的度数(即,这会将图像旋转到位)。

x_translation: 是旋转后将图像向左或向右移动的单位数。由于此平移应用于3D空间,因此单位不是像素...

y_translation: 是旋转后将图像向上或向下移动的单位数。由于此平移应用于3D空间,因此单位不是像素...

zoom是放大图像的量。默认为 1.0。

fov: 是在 3D 空间中旋转图像之前执行 2D-> 3D 投影时要在内部使用的视场。当此值接近 0 时,图像放置在远离视口的无穷远处。当此值接近 180 时,图像将放置在视口中。通常,不应更改此值,但可以对其进行修改以更改 2D->3D 映射效果。

corners: 是四个 (x,y) 元组的列表,这些元组表示四个角,用于创建 4 点对应同调,该同形将第一个角映射到 (0, 0),将第二个角映射到 (image_width-1, 0),将第三个角映射到 (image_width-1, image_height-1),将第四个角映射到 (0, image_height-1)。然后,在重新映射图像后应用 3D 旋转。此参数允许您使用rotation_corr来执行鸟瞰图转换等操作。例如：

top_tilt = 10 # if the difference between top/bottom_tilt become to large this method will stop working
bottom_tilt = 0

points = [(tilt, 0), (img.width()-tilt, 0), (img.width()-1-bottom_tilt, img.height()-1), (bottom_tilt, img.height()-1)]

img.rotation_corr(corners=points)

返回图像对象。

image.get_histogram([threshold[,invert = False[,roi,hist[,l_bins,a_bins,b_bins,difference]]]]]]]])

计算所有color通道上的归一化直方图,并返回 image.直方图对象。有关详细信息,请参阅 image.histogram 对象。也可以使用 roiimage.get_hist()或image.histogram()调用此方法。

thresholds: 如果传递列表,则直方图信息将仅根据阈值列表中的像素计算。

thresholds必须是定义要跟踪的color范围的元组列表。对于灰度图像,每个元组需要包含两个值 - 最小灰度值和最大灰度值。将仅考虑介于这些阈值之间的像素区域。对于 RGB565 图像,每个元组需要有六个值(l_lo、l_hi、a_lo、a_hi、b_lo、b_hi) - 分别是 LAB L、A 和 B 通道的最小值和最大值。为了便于使用,此功能将自动修复交换的最小值和最大值。此外,如果元组大于六个值,则忽略其余部分。相反,如果元组太短,则False定其余阈值处于最大范围。[(lo, hi), (lo, hi), ..., (lo, hi)]

[CAUTION]

要获取要跟踪的对象的阈值,只需在 IDE 帧缓冲区中选择要跟踪的对象上选择(单击并拖动)即可。然后,直方图将更新为仅位于该区域中。然后只需记下color分布在每个直方图通道中开始和下降的位置。这些将是 您的低值和高值。最好手动确定阈值,而不是使用上限和下四分位数统计信息,因为它们太紧了。

您还可以通过在IDE中使用阈值分析工具,来确定color阈值。工具->阈值分析工具

invert: 反转阈值操作,以便匹配某些已知color边界内的像素,而不是匹配已知color边界之外的像素。

除非您需要使用color统计信息执行高级操作,否则只需使用 image.get_statistics() 方法而不是此方法来查看图像中的像素区域。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则使用整个图像。仅对roi中的像素进行操作。

bins 对于灰度图像,是用于直方图通道的条柱数。对于彩色图像,是每个通道使用的图像。每个通道的bins计数必须大于 2。此外,将bins计数设置为大于每个通道的唯一像素值数是没有意义的。默认情况下,historgram 将具有每个通道的最大条柱数。

difference: 可以设置为图像对象,以使该方法对当前图像和图像对象之间的差异图像进行操作。这样就不必使用单独的缓冲区。

image.get_statistics([threshold[,invert = False[,roi[,bins[,l_bins[,a_bins[,b_bins[,difference]]]]]]]])

计算图像所有color通道的平均值、中位数、模式、标准差、最小值、最大值、下四分位数和上限四分位数,并返回 image.statistics 对象。
有关详细信息,请参阅image.statistics 对象。

也可以使用roiimage.get_stats 或 image.statisticsthresholds调用此方法。如果传递列表,则直方图信息将仅根据阈值列表中的像素计算。

thresholds: 是定义跟踪的color范围的元组列表。对于灰度图像,每个元组需要包含两个值 - 最小灰度值和最大灰度值。将仅考虑介于这些阈值之间的像素区域。对于彩色图像,每个元组需要有六个值(l_lo、l_hi、a_lo、a_hi、b_lo、b_hi) - 分别是 LAB L、A 和 B 通道的最小值和最大值。为了便于使用,此功能将自动修复交换的最小值和最大值。此外,如果元组大于六个值,则忽略其余部分。相反,如果元组太短,则使阈值处于最大范围。[(lo, hi), (lo, hi), ..., (lo, hi)]

注意

invert: 反转阈值操作,以便匹配某些已知color边界内的像素,而不是匹配已知color边界之外的像素。

每当需要获取有关图像中像素区域值的信息时,您都需要使用此方法。例如,如果您尝试使用帧差异检测运动,则需要使用此方法确定图像color通道的变化以触发运动检测阈值。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对roi中的像素进行操作。

bins: 其他是用于直方图通道的条柱数。对于灰度图像,请使用RGB565图像,每个通道使用其他图像。每个通道的箱计数必须大于 2。此外,将箱计数设置为大于每个通道的唯一像素值数是没有意义的。默认情况下,historgram 将具有每个通道的最大条柱数。bins

difference: 可以设置为图像对象,以使该方法对当前图像和图像对象之间的差异图像进行操作。这样就不必使用单独的缓冲区。difference

image.get_regression(threshold[,invert=False[,roi[,x_stride=2[,y_stride=1[,area_threshold=10[,pixels_threshold=10[,robust=False]]]]]]])

计算图像中所有阈值像素的线性回归。线性回归通常使用最小二乘法计算,最小二乘法速度很快,但无法处理任何异常值。如果为 True,则使用 Theil–Sen 线性回归来计算图像中所有阈值像素之间所有斜率的中位数。这是一个 N^2 操作,如果在阈值后设置了太多像素,即使在 80x60 图像上,也可能使 FPS 降至 5 以下。但是,只要阈值后设置的像素数仍然很低,线性回归就有效,即使高达 30% 的阈值像素是异常值(例如,它是健壮的)。robust

此方法返回一个 image.line 对象。

thresholds: 必须是定义要跟踪的color范围的元组列表。对于灰度图像,每个元组需要包含两个值 - 最小灰度值和最大灰度值。将仅考虑介于这些阈值之间的像素区域。对于 RGB565 图像,每个元组需要有六个值(l_lo、l_hi、a_lo、a_hi、b_lo、b_hi) - 分别是 LAB L、A 和 B 通道的最小值和最大值。为了便于使用,此功能将自动修复交换的最小值和最大值。此外,如果元组大于六个值,则忽略其余部分。相反,如果元组太短,则False定其余阈值处于最大范围。[(lo, hi), (lo, hi), ..., (lo, hi)]

注意

invert: 反转阈值操作,以便匹配某些已知color边界内的像素,而不是匹配已知color边界之外的像素。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

x_stride: 是评估图像时要跳过的 x 像素数。

y_stride: 是评估图像时要跳过的 y 像素数。

如果回归的边界框面积小于,则返回 None。area_threshold

如果回归的像素计数小于,则返回 None。pixels_threshold

image.find_blobs(threshold[,invert=False[,roi[,x_stride=2[,y_stride=1[,area_threshold=10[,pixels_threshold=10[,merge=False[,=0[,threshold_cb=None[,merge_cb=None[,x_hist_bins_max=0[,y_hist_bins_max=0]]]]]]]]]]]])

查找映像中的所有 blob(通过阈值测试的已连接像素区域),并返回描述每个 blob 的 image.blob 对象列表。有关详细信息,请参阅 image.blob 对象。

thresholds: 必须是定义要跟踪的color范围的元组列表。一次调用最多可以传递 32 个阈值元组。对于灰度图像,每个元组需要包含两个值 - 最小灰度值和最大灰度值。将仅考虑介于这些阈值之间的像素区域。对于 RGB565 图像,每个元组需要有六个值(l_lo、l_hi、a_lo、a_hi、b_lo、b_hi) - 分别是 LAB L、A 和 B 通道的最小值和最大值。为了便于使用,此功能将自动修复交换的最小值和最大值。此外,如果元组大于六个值,则忽略其余部分。相反,如果元组太短,则False定其余阈值处于最大范围。[(lo, hi), (lo, hi), ..., (lo, hi)]

注意

要获取要跟踪的对象的阈值,只需在 IDE 帧缓冲区中选择要跟踪的对象上选择(单击并拖动)即可。然后,直方图将更新为仅位于该区域中。然后只需记下color分布在每个直方图通道中开始和下降的位置。这些将是 您的低值和高值。最好手动确定阈值,而不是使用上限和下四分位数统计信息,因为它们太紧了。thresholds

您还可以通过在 ZNZPI IDE 中进入并从 GUI 滑块窗口中选择阈值来确定color阈值。工具->阈值分析

invert: 反转阈值操作,以便匹配某些已知color边界内的像素,而不是匹配已知color边界之外的像素。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

x_stride: 是搜索 blob 时要跳过的 x 像素数。找到斑点后,线条fill算法将像素精确。增加以加快查找 Blob(如果已知 Blob 很大)的速度。x_stride

y_stride: 是搜索 Blob 时要跳过的 y 像素数。找到斑点后,线条fill算法将像素精确。增加以加快查找 Blob(如果已知 Blob 很大)的速度。y_stride

如果 Blob 的边界框区域小于筛选出的区域。area_threshold

如果 Blob 的像素数小于滤除的像素数。pixels_threshold

merge: 如果为True,合并所有未筛选出的blob,则边界矩形的 blob 会相互相交。可用于在交集测试期间增加或减少 Blob 的边界矩形的大小。例如,如果边距为 1 个 Blob,则边界矩形彼此相距 1 像素的 Blob 将被合并。margin

通过合并 Blob,可以实现color代码跟踪。每个 Blob 对象都有一个值,该值是一个位向量,每个color阈值由 1 组成。例如,如果传递find_blobs image.find_blobs两个color阈值,则第一个阈值的代码为 1,第二个阈值的代码为 1(第三个阈值为 4,第四个阈值为 8,依此类推)。在逻辑上将 Blob 或所有代码合并在一起,以便您知道产生它们的color。这允许您跟踪两种color,如果您用两种color返回一个 blob 对象,那么您知道它可能是一个color代码。code

如果使用的是紧密的color边界,则可能还需要合并 Blob,这些color边界不能完全跟踪您尝试跟踪的对象的所有像素。

最后,如果要合并 blob,但是,不希望合并两个color阈值,则只需使用单独的阈值调用

find_blobs image.find_blobs两次,这样 blob 就不会合并。

threshold_cb可以设置为函数,以便在阈值化后调用每个 blob,以将其从要合并的 blob 列表中筛选出来。回调函数将接收一个参数 - 要筛选的 blob 对象。然后,回调必须返回 True 以保留 blob,并返回 False 以筛选它。

merge_cb可以设置为函数以调用即将合并的每两个 blob,以防止或允许合并。回调函数将接收两个参数 - 要合并的两个 blob 对象。然后,回调必须返回 True 以合并 Blob,或返回 False 以防止合并 Blob。

x_hist_bins_max如果设置为非零,则使用对象中所有列的x_histogram投影fill每个 Blob 对象中的直方图缓冲区。然后,此值设置该投影的条柱数。

y_hist_bins_max如果设置为非零,则使用对象中所有行的y_histogram投影fill每个 Blob 对象中的直方图缓冲区。然后,此值设置该投影的条柱数。

image.find_lines([roi, x_stride=2[, y_stride=1[, 阈值=1000[, theta_margin=25[, rho_margin=25]]]]]])

使用 hough 变换查找图像中的所有无限行。

line: image.line 对象的列表。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

x_stride: 是执行 hough 转换时要跳过的 x 像素数。仅当您要搜索的行又大又笨重时,才增加此值。

y_stride: 是执行 hough 变换时要跳过的 y 像素数。仅当您要搜索的行又大又笨重时,才增加此值。

threshold: 控制从 hough 变换中检测到哪些行。仅返回大小大于或等于 的线。对于您的应用程序而言,正确的值取决于映像。请注意,一条线的大小是构成该线的像素的所有 sobel 滤波器大小之和。thresholdthreshold

theta_margin: 控制检测到的行的合并。相距数和相距数的线将合并。theta_marginrho_margin

rho_margin: 控制检测到的行的合并。相距数和相距数的线将合并。theta_marginrho_margin

该方法的工作原理是在图像上运行sobel滤波器,并从sobel滤波器中获取幅度和梯度响应,以提供hough变换。它不需要首先对映像进行任何预处理。但是,我使用过滤清理图像,您可能会获得更稳定的结果。

image.find_line_segments([roi[, merge_distance=0[, max_theta_difference=15]]])

使用 hough 变换查找图像中的线段。返回 line:image.line 对象的列表。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

merge_distance: 指定要合并的两行分隔线(在一行上的任意点)可以相互分隔的最大像素数。

max_theta_difference: 是要合并的相距两条线相隔的度数的最大θ差。merge_distance

此方法使用 LSD 库(也由 OpenCV 使用)来查找图像中的行分隔。它有点慢,但非常准确,线条不会跳来跳去。

image.find_circles([roi, x_stride=2[, y_stride=1[, threshold=2000[, x_margin=10[, y_margin=10[, r_margin=10[, r_min=2[, r_max[, r_step=2]]]]]]]]]])

使用 hough 变换在图像中查找圆。返回 circle: image.circle 对象的列表。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

x_stride: 是执行 hough 转换时要跳过的 x 像素数。只有在您要搜索的圆圈又大又笨重时才增加此值。

y_stride: 是执行 hough 变换时要跳过的 y 像素数。只有在您要搜索的圆圈又大又笨重时才增加此值。

threshold: 控制从 hough 变换中检测到哪些圆。仅返回大小大于或等于 的圆。对于您的应用程序而言,正确的值取决于映像。请注意,圆的大小是组成该圆的像素的所有 sobel 滤波器大小之和。thresholdthreshold

x_margin: 控制检测到的圆圈的合并。相距的圆 、和像素相距。x_marginy_marginr_margin

y_margin: 控制检测到的圆圈的合并。相距的圆 、和像素相距。x_marginy_marginr_margin

r_margin: 控制检测到的圆圈的合并。相距的圆 、和像素相距。x_marginy_marginr_margin

r_min: 控制检测到的最小圆半径。增加此值可加快算法速度。默认值为 2。

r_max: 控制检测到的最大圆半径。减小此值可加快算法速度。默认值为 min(roi.w/2, roi.h/2)。

r_step: 控制如何步进半径检测。默认值为 2。

image.find_rects([roi=auto[,threshold=10000]])

使用与查找四边形标签相同的四边形检测算法查找图像中的矩形。最适合与背景形成良好对比度的矩形。四边形检测算法可以处理矩形上的任何缩放/旋转/剪切。

返回rect: image.rect 对象的列表。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对roi中的像素进行操作。

threshold: 边缘大小小于threshold 的矩形(通过在矩形边缘上的所有像素上滑动 sobel 运算符并对其值求和来计算)，从返回的列表中过滤掉。

image.find_qrcodes([roi])

查找roi中的所有 qrcode,并返回qrcode: image.qrcode 对象的列表。

QR码需要在图像中相对平坦,此方法才能正常工作。通过使用sensor.set_windowing() 函数放大镜头中心,image.lens_corr()

矫正镜头畸变,或者只是将镜头更换为视野较窄的物体,您可以获得不受镜头畸变影响的更平坦的图像。

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对roi中的像素进行操作。

image.find_apriltags([roi[,families=image.TAG36H11[, fx[, fy[, cx[, cy]]]]]])

查找roi中的所有 apriltag,并返回image.apriltag 对象的列表。有关详细信息,请参阅 image.apriltag 对象。

与QR码不同,AprilTags可以在更远的距离,更差的照明,扭曲的图像等处检测到。AprilTags可以真好的处理各种图像失真问题,这QR码是无法做到的。也就是说,AprilTags只能将数字ID编码为其有效负载。

AprilTags 也可用于本地化目的。每个image.apriltag 对象从相机返回其平移和旋转。平移的单位由 fx 、fy 、cx 和 cy 分别是图像在 X 和 Y 方向上的焦距和中心点确定。

注意

要创建 AprilTags,请使用 IDE 中内置的标签生成器工具。标签生成器可以创建可打印的8.5“x11”标签。

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对roi中的像素进行操作。

families: 是要解码的标记族的位掩码。它是以下各项的逻辑 OR：

image.TAG16H5
image.TAG25H7
image.TAG25H9
image.TAG36H11
image.ARTOOLKIT

默认情况下,它只是图像。TAG36H11 这是最好的标签系列。请注意, image.find_apriltags() 会降低每个已启用标签系列的速度。

fx是相机 X 焦距(以像素为单位)。对于标准的znzp的M12镜头,这是(2.8 / 3.984)* 1920。这是镜头焦距(以毫米为单位),除以X方向上的相机传感器长度乘以X方向上的相机传感器像素数(对于GC2053相机)。

fx是相机 Y 焦距(以像素为单位)。对于标准的znzpi的M12镜头,这是(2.8 / 2.952)* 1080。这是以mm为单位的镜头焦距,除以Y方向上的相机传感器长度乘以Y方向上的相机传感器像素数(对于GC2053相机)。

cx是图像中心,它只是。这不是 。image.width()/2roi.w()/2

cy是图像中心,它只是。这不是 。image.height()/2roi.h()/2

image.find_datamatrices([roi[,effort= 200]])

查找roi中的所有数据矩阵,并返回 image.datamatrix 对象的列表。有关详细信息,请参阅 image.datamatrix 对象。

数据矩阵需要在图像中相对平坦,此方法才能正常工作。通过使用sensor.set_windowing() 函数放大镜头中心,image.lens_corr()

镜头畸变矫正,或者只是将镜头更换为视野较窄的物体,您可以获得不受镜头畸变影响的更平坦的图像。有机器视觉镜头不会引起桶形失真,但它们比OpenMV提供的标准镜头贵得多。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

effort: 控制尝试查找数据矩阵匹配项所花费的时间。默认值 200 应该适用于所有用例。但是,您可以增加工作量,但要以帧速率为代价,才能提高检测率。您也可以降低提高帧速率的工作量,但是,以检测为代价...请注意,当 设置为低于 160 左右时,您将不再检测到任何内容。还要注意,您可以随心所欲地制作高。但是,任何高于240左右的值都不会导致检测率的大幅提高。efforteffort

image.find_barcodes([roi])

查找roi中的所有一维条形码,并返回 image.barcode 对象的列表。

为获得最佳效果,请使用 640 x 40/80/160 窗口。垂直分辨率越低,一切都运行得越快。由于条形码是线性一维图像,因此您只需要在一个方向上获得很大的分辨率,而在另一个方向上只需要一点分辨率。请注意,此功能可水平和垂直扫描,因此您可以根据需要使用 40/80/160 x 480 窗口。最后,确保调整镜头,以便条形码位于焦距产生最清晰图像的位置。模糊的条形码无法解码。

此功能支持所有这些一维条形码(基本上所有条形码)：

image.EAN2
image.EAN5
image.EAN8
image.UPCE
image.ISBN10
image.UPCA
image.EAN13
image.ISBN13
image.I25
image.DATABAR (RSS-14)
image.DATABAR_EXP (RSS-Expanded)
image.CODABAR
image.CODE39
image.PDF417
image.CODE93
image.CODE128

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

image.find_displacement(template[, roi[, template_roi[, logpolar=False]]])

从模板中查找此图像的平移偏移量。这种方法可以用来做光流。此方法返回一个image.displacement 对象,其中包含使用相位相关性的位移计算结果。

roi是要在其中工作的感兴趣区域矩形 (x, y, w, h)。如果未指定,则等于图像矩形。

template_roi是要在其中工作的感兴趣区域矩形 (x, y, w, h)。如果未指定,则等于图像矩形。

roi和 roi 必须具有相同的 w/h,但在图像中可以具有任何 x/y 位置。您可以在较大的图像周围滑动较小的rois以获得光流梯度图像...template

image.find_displacement()

通常计算两个图像之间的 x/y 平移。但是,如果您通过它,它将发现两个图像之间的旋转和缩放更改。相同的 image.displacement 对象结果对两种可能的回复进行编码。logpolar=True

注意

请在 2 的幂图像尺寸(例如传感器.B64X64)。

image.find_template(template,threshold[,roi[,step= 2[,search= image.SEARCH_EX]]])

尝试使用归一化互相关查找图像中模板匹配的第一个位置。返回匹配位置的边界框元组 (x, y, w, h),否则返回 None。

template是与此图像对象匹配的小图像对象。请注意,两个图像都必须是灰度的。

threshold是浮点数 (0.0-1.0),其中较高的阈值可防止误报,同时降低检测率,而较低的阈值则相反。

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

step是查找模板时要跳过的像素数。跳过像素大大加快了算法的速度。这只会影响SERACH_EX模式下的算法。

search可以是 或 。 使用比算法更快的算法搜索模板,但如果模板靠近图像边缘,则可能无法找到模板。 对图像进行详尽的搜索,但可能比 慢得多。image.SEARCH_DSimage.SEARCH_EX

image.SEARCH_DSimage.SEARCH_EX image.SEARCH_EXimage.SEARCH_DS

image.find_features(级联,阈值 = 0.5,比例 = 1.5,roi[[[]]])

此方法在图像中搜索与 Haar 级联中传递的区域匹配的所有区域,并返回围绕这些要素的边界框矩形元组 (x, y, w, h) 的列表。如果未找到任何要素,则返回空列表。

cascade是一个 Haar Cascade 对象。见图。HaarCascade() 了解更多详情。

threshold是一个阈值 (0.0-1.0),其中较小的值可提高检测率,同时提高误报率。相反,较高的值会降低检测率,同时降低误报率。

scale是必须大于 1.0 的浮点数。比例因子越高,运行速度越快,但图像匹配度越差。一个好的值介于 1.35 和 1.5 之间。

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

image.find_eye(roi)

在眼睛周围的感兴趣区域(x,y,w,h)元组中搜索瞳孔。返回一个元组,其中包含图像中瞳孔的 (x, y) 位置。如果未找到瞳孔,则返回 (0,0)。

要使用这个函数,首先使用image.find_features()和HaarCascade来查找某人的脸。然后使用image.find_features()与HaarCascade一起使用来查找脸上的眼睛。最后,对image.find_features()返回的眼睛ROI调用此方法以获取瞳孔坐标。frontalfaceeye

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。roi

仅适用于灰度图像。

image.find_lbp(roi)

从感兴趣区域(x、y、w、h)元组中提取 LBP(局部二进制模式)关键点。然后,您可以使用然后使用image.match_descriptor()函数来比较两组关键点,以获得匹配的距离。

roi是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。

仅适用于灰度图像。

image.find_keypoints([roi,阈值= 20,规范化= False,scale_factor = 1.5,max_keypoints = 100,corner_detector = 图像。CORNER_AGAST[[[[[]]]]]])

从感兴趣区域 (x, y, w, h) 元组中提取 ORB 关键点。然后,您可以使用然后使用 image.match_descriptor()函数来比较两组关键点,以获得匹配的区域。如果未找到任何关键点,则返回 None。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对 中的像素进行操作。

threshold: 是一个数字(介于 0 - 255 之间),用于控制提取角的数量。对于默认的 AGAST 角探测器,此值应为 20 左右。FOr 快速角检测器,这应该在 60-80 左右。阈值越低,您获得的提取角就越多。

normalized: 是一个布尔值,如果 True 将关闭以多种分辨率提取关键点。如果您不关心处理缩放问题并希望算法运行得更快,请将此值设置为 true。

scale_factor: 是必须大于 1.0 的浮点数。比例因子越高,运行速度越快,但图像匹配度越差。一个好的值介于 1.35 和 1.5 之间。

max_keypoints: 是关键点对象可以持有的最大关键点数。如果关键点对象太大并导致 RAM 不足问题,则减小此值。

corner_detector: 是用于从图像中提取关键点的角检测器算法。它可以是任一图像。CORNER_FAST或图像。CORNER_AGAST。FAST角探测器速度更快,但精度要低得多。

image.find_edges(edge_type[,threshold])

将图像转换为黑白,仅留下边缘作为白色像素。

image.EDGE_SIMPLE - 简单的阈值高通滤波器算法。
image.EDGE_CANNY - Canny边缘检测算法。

threshold: 是包含低阈值和高阈值的双值元组。您可以通过调整这些值来控制边的质量。它默认为 (100, 200)。

将 ROI 中的像素替换为 HOG(定向粒度的直方图)线。

roi: 是感兴趣区域矩形元组 (x, y, w, h)。如果未指定,则等于图像矩形。仅对roi中的像素进行操作。

ai.load(path)
path:模型所在的路径，默认导入的次序为：1 TF卡 2 MTP的userdata 3 flash。
如果使用的是cnn模型的路径，则会导入其数据并建立模型。
如果使用的是如下预制的模型，则导入预制模型。

  FACE_DETECTION = 1,      #人脸检测
  FACE_LANDMARK_68 = 2,    #人脸68特征点定位
  FACE_RECOGNIZE = 3,      #人脸识别
  FACE_ANALYZE = 4,        #人脸分析
  OBJECT_DETECTION = 5,    #目标检测
  POSE_BODY = 6,           #身体骨骼关键点定位
  POSE_FINGER_21 = 7,      #手指21关键点定位
  FACE_LANDMARK_5 = 8,     #人脸5特征点定位
  HEAD_DETECTION = 9,      #人头检测
  CARPLATE_DETECTION = 10, #车牌检测
  CARPLATE_ALIGN = 11,     #车牌矫正对齐
  CARPLATE_RECOG = 12,     #车牌识别
  OBJECT_TRACK = 13,       #目标跟踪
  POSE_FINGER_3 = 14,      #手指3点定位
  FACE_LIVENESS = 15       #人脸活体检测，暂不支持
  FACE_COMPARE             #人脸特征对比

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_DETECT)
print(ml)

img = image.Image('face.jpg')
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    print(img)
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    for it in out:
        print(it.rect())
        img.draw_rectangle(it.rect(),color=(255,0,0), thickness=4)

ai.forward(img,roi)

img: 需要进行计算的图像，可以由image.Image(path)导入的jpg图片，也可以是sensor.snapshot()得到的实时图像
    图像的大小必须是和模型训练时一样尺寸。
roi: 需要处理的感兴趣区域

如果在load中使用的是cnn的模型，则还需要调用ai.prob()，来对姐u共进行进一步处理，得到推理结果。

如果使用的是预制的模型，则会直接得到推理结果。结果的格式参考下面的各个检测的描述。

ai.prob(res,cnt)

res：forward 计算的结果
返回按概率由大到小的顺序的cnt个结果

int   object.id() 目标分类
int   cls_idx()   目标类索引
tupel rect()      目标位置,返回四个int值，分别是left,top,right,bottom
float score()     目标分辨得分
int   x()         目标位置的左上角x坐标
int   y()         目标位置的左上角y坐标
int   w()         目标的宽度
int   h()         目标的高度
string name()     目标分类名称

分别是
"???", "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat",
"trafficlight", "firehydrant", "???", "stopsign", "parkingmeter", "bench", "bird", "cat", "dog", "horse",
"sheep", "cow", "elephant", "bear", "zebra", "giraffe", "???", "backpack", "umbrella", "???",
"???", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sportsball", "kite", "baseballbat",
"baseballglove", "skateboard", "surfboard", "tennisracket", "bottle", "???", "wineglass", "cup", "fork", "knife",
"spoon", "bowl", "banana", "apple", "sandwich", "orange", "broccoli", "carrot", "hotdog", "pizza",
"donut", "cake", "chair", "couch", "pottedplant", "bed", "???", "diningtable", "???", "???",
"toilet", "???", "tv", "laptop", "mouse", "remote", "keyboard", "cellphone", "microwave", "oven",
"toaster", "sink", "refrigerator", "???", "book", "clock", "vase", "scissors", "teddybear", "hairdrier",
"toothbrush"

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_DETECT)
print(ml)

roi = (620,220,640,640)
def loop():
    img = sensor.snapshot() #获取实时图像
    #print(img)
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    for it in out:
        print(it.rect())
        img.draw_rectangle(it.rect(),color=(255,0,0), thickness=4)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_DETECT)
print(ml)

img = image.Image('face.jpg') #读取图片
roi = (0,0,612,344)
def loop():
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    for it in out:
        print(it.rect())
        img.draw_rectangle(it.rect(),color=(255,0,0), thickness=4)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_RECONG)
print(ml)

img = image.Image('face.jpg')
#roi = (820,320,640,640)
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    print(img)
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    for it in out:
        print(it)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_ANALYZE)
print(ml)

img = image.Image('face.jpg')
#roi = (820,320,640,640)
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    print(img)
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_RECONG)
fc = ai.load(ai.FACE_COMPARE)
print(ml)

img_a = image.Image('face_a.jpg')
img_b = image.Image('face_b.jpg')
#roi = (820,320,640,640)
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    img_a.draw_image(img,(0,0))
    img_b.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out_a = ml.forward(img_a,roi=roi)
    out_b = ml.forward(img_b,roi=roi)
    out = fc.forward(out_a,out_b)
    print(out)

返回一个代表面部姿态位置的face类型的数据。
其有如下的部分组成：

int   face.width()      面部图像的宽度
int   face.height()     面部图像的高度
int   face.rect()       面部的位置
int   face.x()          面部的左上角x坐标
int   face.y()          面部的左上角y坐标
int   face.w()          面部的宽度
int   face.h()          面部的高度
int   face.count()      面部坐标的数量
tuple face.landmarks()  面部坐标(x,y)的元组
float face.pose()       面部的姿态，一个浮点数
float face.score()      面部检测的得分，一个浮点数
image face.image()      面部区域图像，此函数只有在使用ai.FACE_LAND5才有，使用ai.FACE_LAND68返回空值

如果forward()失败，则识别返回一个空值。

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_LANDMARK_68)
print(ml)

img = image.Image('face_a.jpg')
#roi = (820,320,640,640)
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    ou = ml.forward(img,roi=roi)
    print(out)
    if out :
        img.draw_image(out.image(),(200,200))

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_LAND68)
print(ml)

img = sensor.snapshot()
roi = (720,320,740,640)
def loop():
    img = sensor.snapshot()
    #img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    if out :
        print(out.count())
    print(out)
    print(out.rect())
    #for it in out.landmarks():
    #    img.draw_circle((it[0],it[1],10), color=(255,0,0), thickness=4)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.OBJECT_DETECT)
print(ml)

img = image.Image('cat.jpg')
print(img)
img.draw_image(img,(0,0))
#roi = (820,320,640,640)
roi = (0,0,612,344)
def loop():
    #img = sensor.snapshot()
    img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    for it in out:
        print(it.rect())
        img.draw_rectangle(it.rect(),color=(255,0,0), thickness=4)
        print(it.name())


import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.OBJECT_DETECT)
tk = ai.load(ai.OBJECT_TRACK)
print(ml)

img = sensor.snapshot()
print(img)
roi = (720,320,740,640)
def loop():
    img = sensor.snapshot()
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)
    for it in out:
        tout = tk.forward(img,roi=it.rect())
        if tout :
            print(tout)

load(ai.CARPLATE_ALIGN)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.CARPLATE_RECOG)

img = sensor.snapshot()
#img = image.Image('face.jpg')
print(img)
print(ml)
#img.draw_image(img,(0,0))
roi = (720,320,740,640)
#roi = (0,0,612,340)
def loop():
    img = sensor.snapshot()
    #img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.POSE_FINGER)
print(ml)

img = sensor.snapshot()
roi = (720,320,740,640)
def loop():
    img = sensor.snapshot()
    #img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)
    for it in out:
        img.draw_circle((it[0],it[1],10), color=(255,0,0), thickness=4)

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.POSE_BODY)
print(ml)

img = sensor.snapshot()
roi = (720,320,740,640)
def loop():
    img = sensor.snapshot()
    #img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)
    for it in out:
        img.draw_circle(it, color=(255,0,0), thickness=4)

使用ai.FACE_LAND5 作为ai.load()的参数。返回一个带图像的face类型

import image
import sensor
import ai

sensor.reset()

ml = ai.load(ai.FACE_LAND5)
print(ml)

img = sensor.snapshot()
roi = (720,320,740,640)
def loop():
    img = sensor.snapshot()
    #img.draw_image(img,(0,0))
    img.draw_rectangle(roi, color=(255,0,0), thickness=4)
    out = ml.forward(img,roi=roi)
    print(out)
    for it in out.landmarks():
        img.draw_circle((it[0],it[1],10), color=(255,0,0), thickness=4)

import network

SSID='youvtec'  # Network SSID
KEY='88888888'  # Network key

print("Trying to connect... (may take a while)...")

wlan = network.WIFI()
wlan.connect(SSID, key=KEY, security=wlan.WPA_PSK)

def loop():
    #get IP
    print(wlan.ifconfig())
    #scan ap
    aps = wlan.scan()
    print(aps)

import image, time, fir

fir.init(type=fir.FIR_MLX90640, refresh=4,id=5) # 16Hz, 32Hz or 64Hz.

# FPS clock
clock = time.clock()
print(clock)

def loop():
    clock.tick()
    img = fir.snapshot()
    img.draw_image(img,(100,20),x_scale=10.0,y_scale=10.0)
    # Print FPS.
    print(clock.fps())