使用5行代码的实时图像分割-600学习网

600学习网终身会员188，所有资源无秘无压缩-购买会员

目录

1.计算机视觉应用中的图像分割

2.图像分割

3.批量图像分割

4.视频分割

5.摄像机视频的分割

计算机视觉应用中的图像分割

计算机视觉是计算机看到和分析所看到的东西的能力。图像分割是计算机视觉的一个方面，它处理将计算机可视化对象的内容分割为不同类别以便更好地进行分析。

图像分割过程的一个很好的例子是图像中对象的前景背景分离，这是一种将对象与其背景分离的技术，用于分析对象及其背景。图像分割实现前景背景分离的能力使其成为解决医学图像分析.背景编辑.自主车辆视觉和卫星图像分析等计算机视觉问题的重要领域。

PixelLib库是一个使用几行python代码在图像和视频中轻松集成对象分割的库。它支持许多惊人的功能，例如：

1.图像和视频中对象的语义和实例分割。

2.细分模型的定制培训。

3.图像和视频中的背景编辑。

4.提取图像和视频中的对象。

实时图像分割应用的要求

Python PixelLib：计算机视觉的最大挑战之一是保持实时应用程序的精度和速度性能之间的距离。在计算机视觉领域，计算机视觉解决方案要么更准确.更慢，要么更不准确.更快，这是一个两难局面。

早期版本的深度学习库使用tensorflow深度学习库作为背景，并使用Mask R－CNN进行分割。掩码R-CNN是一个非常好的架构，但它无法在实时应用中平衡准确姓和速度性能。

PixelLib现在支持pytorch的后端，并使用PointRend分割架构来执行图像和视频中对象的更快.更准确的分割和提取。

Alexander Kirillov等人的PointRender对象分割体系结构用于代替Mask R-CNN来执行对象实例分割。PointRend是一种用于对象分割的高级神经网络。它生成准确的分割模板，并以高推理速度运行，以满足对准确和实时计算机视觉应用的不断增长的需求。

多操作系统支持

PixelLib是一个支持不同操作系统的库。我通过仅支持Linux操作系统的Detectron2将PixelLib与PointRend的python实现集成。

我修改了最初的Detectron2 PointRend实现，以支持Windows操作系统。我很高兴告诉你一个好消息。PixelLib的PointRend实现支持Linux和Windows操作系统。

上述示例图像是PointRend和Mask RCNN的分割结果之间的差异的示例。很明显，右侧的PointRend图像比左侧的Mask R-CNN图像分割效果更好。

注意：本文使用pytorch和PointRend执行实例拆分。

下载Python

PixelLib python版本支持python 3.7及以上版本。下载兼容的Python版本。

安装PixelLib及其依赖项

安装Python

PixelLib Python版本支持这些版本的Python(1.6.0.1.7.1.1.8.0和1.9.0)。注意：不支持Python1.7.0。请不要使用低于1.6.0的任何Python版本。请安装兼容版本的Python。

安装Pycocols

pip3安装pycocotools

安装pixellib

pip3安装pixellib

如果已安装，请使用以下软件升级到最新版本：

pip3安装pixellib-升级

图像分割

PixelLib使用五行python代码执行对象分割

第5行：我们调用函数segmentImage来执行图像中对象的分割，并向函数添加以下参数：

Image_path：这是要分割的图像的路径。

Show_bbox：这是一个可选参数，用于显示带边框的分段结果。

Output_image_name：这是保存的分段图像的名称。

用于分割的示例图像

ins.segmentImage(“image.jpg”，output_image_name＝”output.jpg”)

分割的图像

检查点状态_ dict包含模型未使用的密钥：建议_生成器。锚_生成器。单元格_锚。｛0，1，2，3，4｝

如果您正在运行分段代码，上面的日志可能会出现！这不是错误，代码可以正常工作！

获取分段结果

results，output＝ins.segmentImage(“image.jpg”，show＿bboxes＝True，output＿image＿name＝”result.jpg”)打印(结果)

分割结果返回包含与图像中的分割对象相关的许多值的字典。打印结果将采用以下格式：

｛”boxes”：数组(〔579，462，1105，704〕，〔1，486，321，734〕，[321，371，423，742〕，〔436，369，565，788〕，〔191，397，270，532〕，[1138，357，1197，482〕，[877，382，969，477〕)，”class _ id”：数组([2,2,0,0,0,1,0,2,00,00,2,2,24,2,2,2,0,0，0,0]，dtype＝int64)

“class _ names”：[“汽车”，”汽车”.”人”，”人”.”个人”.”某人”.”人物”.”汽车””.”人员”.”人士”.”此人”.”他人”.”本人”.”私人”.”车”.”背包”.，”人”]

“物体计数”：计数器(｛”人”：15，”车”：7，”背包”：2｝)

“分数”：数组([100.，100.，100.100.，99..，99.，99.，98.，97.，96.，95.，95.,95.，94.，94.,93.，91.，90.，88.，82.，72.，69.，66.]，dtype＝float32)

“掩码”：数组(〔〔False，False，假，…，假，假，False〕

〔假.假.假….假.真.假〕

“提取的_个对象”：〔〕

上面打印的结果值包括：

｛’boxes’：数组(〔5.790e＋02，4.620e＋02.1.105e＋03，7.050e＋02〕，〔1.000e＋00，4.870e＋02，3.220e＋02，7.340e＋02】，〔1.142e＋03.3.640e＋02.1.161e＋03.4.060e＋02〕，数据类型＝float32)

框：这些是分割对象的边界框坐标。我没有显示所有方框的坐标，因为列表太长了。

‘class _ ids’：数组([2，2，0，0，0,0，0，0，2，0,0,0,14,2,2,2,0,0，0,,0,0.0,0]，dtype＝int64)

Class_id：这些是分段对象的类ID。

“class _ names”：[“汽车”，”汽车”.”人”，”人”.”个人”.”某人”.”人物”.”汽车””.”人员”.”人士”.”此人”.”他人”.”本人”.”私人”.”车”.”背包”.，”人”]

Class_name：这些是分段对象的类名。

“物体计数”：计数器(｛”人”：15，”车”：7，”背包”：2｝)

Object_counts：这是图像中划分的每个类的计数。我使用python内置计数器来计数对象。在本例中，图像中分割了15个人.7辆汽车和2个背包。

“分数”：数组([100.，100.，100.100.，99..，99.，99.，98.，97.，96.，95.，95.,95.，94.，94.,93.，91.，90.，88.，82.，72.，69.，66.]，dtype＝float32)

分数：这些是每个分割对象的置信度分数。

“掩码”：数组(〔〔False，False，假，…，假，假，False〕

〔假.假.假….假.真.假〕

遮罩：这些是每个分割对象的遮罩值。我没有显示所有掩码值，因为列表太长。

注意：返回掩码的默认值为布尔值。可以使用新参数mask_points_values来获取遮罩的坐标。

ins.segmentImage(“sample.jpg”，show＿bboxes＝True，mask＿points＿values＝True.output＿image＿name＝”output.jpg”)

mask_points_values参数已添加到segmentImage函数并设置为true。新的掩码值将为：

〔〔数组(〔295，497〕〕)

数组(〔422，114〕.〔421，115〕.〔417，115〕，….〔436，115〕和〔433，115〕)〕

提取的对象：这是容器

提取的对象：如果我们提取对象，这是用于提取对象值的容器列表。它是空的，因为我们没有提取任何东西。我们将在本文后面讨论如何提取这些分割对象。

results，output＝ins.segmentImage(“image.jpg”，show＿bboxes＝True，output＿image＿name＝”result.jpg”)

访问分段结果呈现的值

边界框坐标值

结果[“方框”]

类ID值

结果[“class _ids”]

类名称值

结果[“类名称”]

对象计算值

结果[“物体计数”]

掩码值

结果[“口罩”]

检测阈值

PixelLib使确定目标分割的检测阈值成为可能。

ins.load＿模型(“pointrend＿resnet50.pkl”，置信度＝0.3)

置信度：这是load_model函数中引入的一个新参数。将其设置为0.3可以将检测阈值设置为30%。我为检测阈值设置的默认值为0.5，可以使用置信度参数来增加或减少该值。

速度记录

PixelLib使执行实时对象分割成为可能，并提高了调整推理速度以适应实时预测的能力。使用4GB Nvidia GPU处理单个图像的默认推断速度约为0.26秒。

速度调节：

PixelLib支持速度调整。有两种速度调节模式，即快速模式和快速模式：

1快速模式

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

在load_model函数中，我们添加参数detection_speed并将值设置为fast。在快速模式下处理单个图像的时间达到0.20秒。

快速模式检测的完整代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

ins.segmentImage(“image.jpg”，显示_bboxes＝True，输出_image_name＝”output _image.jgg”)

2快速模式

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

在load_model函数中，我们添加参数detection_speed并将值设置为rapid。在快速模式下处理单个图像的时间达到0.15秒。

快速模式检测的完整代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

ins.segmentImage(“image.jpg”，显示_bboxes＝True，输出_image_name＝”output _image.jgg”)

PointRend模型

对象分割有两种类型的PointRend模型：resnet50变体和resnet101变体。

本文通篇使用resnet50变体，因为它更快.更准确。resnet101变体更准确，但比resnet50变体慢。根据Detectron 2模型的官方报告，COCO上resnet50变体的mAP达到38.3，COCO的resnet101变体的mAP达到40.1

Resnet101的速度记录：默认分割速度为0.5秒，快速模式为0.3秒，快速方式为0.25秒。

Resnet101变体的代码导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet101.pkl”，网络＿主干＝”resnet101”)

ins.segmentImage(“sample.jpg”，show＿bboxes＝True，output＿image＿name＝”output.jpg”)

ins.load＿模型(“pointrend＿resnet101.pkl”，网络＿主干＝”resnet101”)

使用resnet101模型执行推理的代码是相同的，只是我们在load_model函数中加载了PointRend resnet101。从这里下载resnet101模型。我们还添加了一个额外的参数network_backbone，并将值设置为resnet101。

注意：如果您想获得高推理速度和精度，请使用PointRend resnet50变体，但如果您更关心精度，请选择PointRend resnet101变体。所有这些推断报告都基于使用4GB容量的Nvidia GPU。

图像分割中的自定义对象检测

使用的PointRend模型是一个预先训练的COCO模型，它支持80种类型的对象。PixelLib支持自定义对象检测，这使得过滤检测和确保目标对象的分割成为可能。我们可以从支持的80种对象中进行选择，以实现我们的目标。支持以下80种类型的对象：

人，自行车，汽车，摩托车，飞机

公共汽车.火车.卡车.船.交通灯.消防栓.停车标志.

停车场_米.长凳.鸟.猫.狗.马.羊.牛.大象.熊.斑马.

长颈鹿，背包，伞，手提包，领带，手提箱，飞盘，滑雪板

体育运动-球.风筝.棒球-球棒.棒球-手套.滑板.冲浪板.网球-球拍.

瓶子.葡萄酒.杯子.叉子.刀子.汤匙.碗.香蕉.苹果.三明治.橘子.

花椰菜.胡萝卜.热狗.披萨.甜甜圈.蛋糕.椅子.沙发.盆栽植物.床.

餐桌.卫生间.电视.笔记本电脑.鼠标.遥控器.键盘.手机.微波炉.

烤箱.烤面包机.水槽.冰箱.书.钟.花瓶.剪刀.泰迪熊.吹风机.

牙刷。

我们希望对样本图像的检测结果进行过滤，以便仅检测到图像中的人。

目标＿类＝ins.选择＿目标＿类别(人＝真)

ins.segmentImage(“image.jpg”，segment_target_classes＝target_Classs，output_image_name＝”output.jpg”)

调用函数select_target_classes选择要分割的目标对象。函数segmentImage获得一个新参数segmente_target_class，可以从目标类中选择并根据它们进行过滤。

PixelLib仅检测图像中的人。

自定义对象检测的完整代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

目标＿类＝ins.选择＿目标＿类别(人＝真)

ins.segmentImage(“image.jpg”，show＿bboxes＝True，segment＿target＿class＝target＿classes，output＿image＿name＝”output＿-image.jpg”)

图像中的对象提取

PixelLib使提取和分析图像中的分割对象成为可能。

对象提取代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.segmentImage(“image.jpg”，show＿bboxes＝True，extract＿segment＿objects＝True

保存＿提取的＿对象＝True，输出＿图像＿名称＝”output＿图像.jpg”)

图像分割的代码是相同的，只是我们向segmentImage函数添加了额外的参数来执行对象提取。

ins.segmentImage(“image.jpg”，提取＿分割的＿对象＝True，保存＿提取的＿目标＝True.输出＿图像＿名称＝”output.jpg”)

提取分割对象：这是用于处理分割对象提取的参数。使用以下命令访问提取的对象值：

results，output＝ins.segmentImage(“image.jpg”，show＿bboxes＝True，output＿image＿name＝”result.jpg”)

#从结果中访问提取的对象

结果[“提取的对象”]

Save_extracted_objects：这是将每个提取的对象保存为图像的参数。每个分段对象都保存为分段对象索引，例如分段对象1。对象按提取顺序保存。

分段对象_1.jpg

分段对象

分段对象3.jpg

分段对象对象4.jpg

分段对象_5.jpg

分段对象_6.jpg

从遮罩坐标提取对象

注意：图像中的所有对象都已提取，我选择只显示其中的两个。

边界框坐标提取

默认提取方法从遮罩的坐标中提取对象。提取仅为我们提供关于对象本身的信息，而不是其周围环境的信息。

考虑一个问题，我们要分析图像中的对象和区域。PixelLib可以通过使用边界框坐标来提取分割对象及其在图像中的远程位置来解决这个问题。

修改提取的代码

ins.segmentImage(“image.jpg”，提取＿分割的＿对象＝True，从＿框中提取＿＝True.保存＿提取的＿目标＝True和输出＿图像＿名称＝”output.jpg”)

我们引入了一个新参数extract_from_box，用于提取从边界框坐标中分割的对象。每个提取的对象都保存为对象提取索引，例如对象提取1。对象按提取顺序保存

对象_提取1.jpg

对象_提取2.jpg

对象_提取3.jpg

对象_提取4.jpg

对象_提取5.jpg

对象_提取6.jpg

使用边界框坐标提取对象的完整代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.segmentImage(“image.jpg”，show＿bboxes＝True，extract＿segmented＿objects＝True.extract _ from＿box＝True

保存＿提取的＿对象＝True，输出＿图像＿名称＝”output＿图像.jpg”)

图像分割输出的可视化。PixelLib可以根据图像分辨率调整图像可视化。

ins.segmentImage(“sample.jpg”，show＿bboxes＝True，output＿image＿name＝”output.jpg”)

可视化效果不可见，因为文本大小和框厚度太小。我们可以调整文本大小.厚度和框厚度来调整可视化效果。

修改以获得更好的可视化效果

ins.segmentImage(“sample.jpg”，show _bboxes＝True，text _size＝5，text _ thickness＝4，box _ thickne＝10，output _image _ name＝”output.jpg”)

segmentImage函数接受新参数来调整文本和边框的厚度。

Text_size：默认文本大小为0.6，即使是中等分辨率图像。对于高分辨率图像来说，它太小了。我将值增加到5。

Text_thickness：默认文本厚度为1。我将其增加到4以匹配图像分辨率。

Box_thickness：默认框厚度为2，我将其更改为10以匹配图像分辨率。输出具有更好可视化效果的图像

注：根据图像分辨率调整参数。如果图像分辨率较低，我用于分辨率为5760 x 3840的样本图像的值可能太大。如果您有一个非常高的分辨率图像，可以将参数值增加到我在示例代码中设置的参数值之外。

text_thickness和box_thickne参数的值必须是整数，不能用浮点数表示。文本大小值可以表示为整数和浮点数。

批量图像分割

PixelLib可以对位于同一文件夹中的一批图像执行预测。批次拆分代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，output＿folder＿name＝”output folder”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，output＿folder＿name＝”output folder”)

批量分割的代码与单个图像分割的代码非常相似，只是我们将segmentImage函数替换为segmentBatch函数。我们向segmentBatch添加了以下参数：

Folder_path：这是包含要分割的图像的文件夹。

Output_folder_name：这是我们将保存所有分割图像的文件夹的名称。文件夹结构示例

—input文件夹

–test1.jpg–test2.jpg–test.jpg

–output文件夹–test1.jpg–test2.jpg–test.jpg

批量图像分割中的目标提取代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，extract＿segment＿objects＝True

save＿extracted＿objects＝True，output＿folder＿name＝”output folder”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，extract＿segment＿objects＝True.save＿extracted＿obacts＝Tru，output＿folder＿name＝”outputfold”)

我们将extract_segmented_objects和save_extracted_object参数添加到segmentBatch函数中，以分别提取和保存提取的对象。输入文件夹中每个图像的提取对象将保存在一个单独的文件夹中，该文件夹的名称为imagename_extracts。例如，如果图像名称为test1.jpg，这意味着提取的对象将保存在名为test1_extracts的文件夹中。

注意：提取对象的文件夹是在图像的同一输入文件夹中创建的。

—input＿文件夹–test1.jpg–test1＿提取物–test2.jpg–test2＿提取物－test3.jpg–test3＿提取物

—output文件夹

–test1.jpg–test2.jpg–test.jpg

从边界框坐标中提取对象的代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，extract＿segment＿objects＝True

save＿extracted＿objects＝True，output＿folder＿name＝”output folder”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，extract＿segment＿objects＝True；extract＿from＿box＝True.save＿extract

objects＝True，output＿folder＿name＝”output folder”)

我们将extract_from_box和save_extracted_objects参数添加到segmentBatch函数，以分别提取和保存提取的对象。

注意：从边界框坐标提取的对象文件夹也在图像的同一输入文件夹中创建。文件夹结构示例

—input文件夹–test1.jpg–test1摘要

－test2.jpg－test2＿提取物

–test3.jpg–test3_提取物

–output文件夹–test1.jpg–test2.jpg–test.jpg

批量图像分割中的自定义对象分割代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

目标＿类＝ins.选择＿目标＿类别(人＝真)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，segment＿target＿classes＝target＿class，output＿folder＿name＝”output folder”)

目标＿类＝ins.选择＿目标＿类别(人＝真)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，segment＿target＿classes＝target＿class，output＿folder＿name＝”output folder”)

我们调用函数select_target_classes来选择要分割的目标对象。segmentBatch函数获得一个新参数segmente_target_class，可以从目标类中选择并根据它们进行过滤。

批量图像分割中的快速模式检测代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，output＿folder＿name＝”output folder”)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

在load_model函数中，我们添加参数detection_speed并将值设置为fast。在快速模式下处理单个图像的时间达到0.20秒。

批量图像分割中的快速模式检测代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

ins.segmentBatch(“inputfolder”，show＿bboxes＝True，output＿folder＿name＝”output folder”)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

我们将推理的检测速度设置为快速模式。

在load_model函数中，我们添加参数detection_speed并将值设置为rapid。在快速模式下处理单个图像的时间达到0.15秒。

注：PixelLib所有支持函数的批量图像分割的代码实现与单个图像分割的相同，只是segmentImage函数被segmentBatch替换。

视频和摄像机中的对象分割

PixelLib可以在实时相机和视频文件中执行实时对象分割。

视频分割

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，frames＿per＿second＝3，output＿video-name＝”output＿video.mp 4”)

第1-4行：PixelLib包已导入。我们还从模块PixelLib.torchebackend导入了instanceSegmentation类。实例(实例分段类可以从pythoch支持导入)。我们创建了这个类的一个实例，最后加载了PointRend模型。如果模型尚未下载，请在此处下载。

第5行：我们调用函数process_video来分割视频中的对象，并向函数添加以下参数：

Video_path：这是要分割的视频的路径。

Show_bboxs：这是一个可选参数，用于在结果中显示带有边界框的分段对象。

Frames_per_second：此参数将设置保存视频的每秒帧数。

Output_video_name：这是输出分段视频的名称。ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，frames＿per＿second＝3，output＿video-name＝”output＿video.mp 4”)

视频中的对象提取代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.process＿video(“sample.mp4″，show＿bboxes＝True，extract＿segmented＿objects＝True

保存＿提取的＿对象＝True，每＿秒帧数＝3，输出＿视频＿名称＝”output＿视频.mp4″)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，extract＿segmented＿objects frames＿per＿second＝5，output＿video-name＝”output＿video.mp 4”)

process_video函数有新参数extract_segmented_objects和save_extracted_object，分别用于提取和保存分割对象。

视频中边界框坐标的提取

修改提取的代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

ins.process＿video(“sample.mp4″，show＿bboxes＝True，extract＿segmented＿objects＝True.extract _ from＿box＝True

保存＿提取的＿对象＝True，每＿秒帧数＝5，输出＿视频＿名称＝”output＿视频.mp4″)

ins.process＿video(“sample.mp4″，show＿bboxes＝True，extract＿segmented＿objects＝True.extract＿from＿box＝True)，save＿extracted＿obacts＝Tru，frames＿per＿second＝5，output＿video＿name＝”output＿video.mp4”)

将extract_from_box添加到函数中，以从其边界框坐标中提取对象分割。

视频中的自定义对象分割

PixelLib可以在视频中执行自定义对象分割，以过滤未使用的检测和分割对象类。

视频中的自定义检测代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”)

目标＿类＝ins.选择＿目标＿类别(人＝真，自行车＝真)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，segment＿target＿classes＝target＿class

帧数＿每＿秒＝5，输出＿视频＿名称＝”output＿视频.mp4″)

目标＿类＝ins.选择＿目标＿类别(人＝真，自行车＝真)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，segment＿target＿class＝target＿＿class，frames＿per＿second＝5

output＿video＿name＝”output＿video.mp4″)

调用函数select_target_classes选择要分割的目标对象。函数process_video获得一个新的参数segment_target_classes，该参数可以从目标类中选择并基于它们进行过滤。

视频分割中的快速模式检测码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，frames＿per＿second＝5，output＿video-name＝”output＿video.mp 4”)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

我们将视频处理的检测速度设置为快速模式。

视频分割中的快速模式检测码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

ins＝实例分段()

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

ins.process＿video(“sample＿video.mp4″，show＿bboxes＝True，frames＿per＿second＝5，output＿video-name＝”output＿video.mp 4”)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

我们将视频处理的检测速度设置为快速模式。

实时相机中的目标分割

PixelLib为实时摄像机的实时分割提供了极好的支持。分割实时相机的代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

导入cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

分段_视频.加载_模型(“pointrend _ resnet50.pkl”)

segment_video.process_camera(捕获，显示_bboxes＝True，每_second＝5帧，检查_fps＝True.显示_frames＝True)

帧名称＝”帧”，输出视频名称＝”输出视频.mp4″)

导入cv2捕获＝cv2.VideoCapture(0)

我们导入了cv2并包含了用于捕获相机帧的代码。

segment＿video.process＿camera(捕获，显示＿bboxes＝True，帧＿每秒＝5，检查＿fps＝True.显示＿帧＝True和帧＿名称＝”帧”，输出＿video＿名称=”输出＿视频.mp4″)

在分割代码中，我们将视频的文件路径替换为捕获，也就是说，我们正在处理摄像机捕获的帧流。我们添加了其他参数来显示相机帧：

Show_frames：此参数用于处理分段摄影机帧的显示。

Frame_name：这是指定给显示的相机帧的名称。

Check_fps：这是相机馈送处理结束时每秒打印的帧数参数。

Show_bboxs：这是一个可选参数，用于显示带有边界框的分段对象。

Frames_per_second：此参数用于设置已保存视频文件的每秒帧数。在这种情况下，它被设置为5，即保存的视频文件每秒有5帧。

Output_video_name：这是保存的分段视频的名称。

实时相机进给处理的速度调整

默认速度模式达到4fps。快速模式达到6fps，快速模式达到9fps。这些报告基于使用4GB容量的Nvidia GPU

相机馈送中的快速模式检测代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

导入cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

segment＿video.load＿model(“pointrend＿resnet50.pkl”，检测速度＝”fast”)

segment_video.process_camera(捕获，显示_bboxes＝True，每_second＝5帧，检查_fps＝True.显示_frames＝True)

帧名称＝”帧”，输出视频名称＝”输出视频.mp4″)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”fast”)

我们将处理实时相机馈送的检测速度设置为快速模式，推断速度为6fps。快速模式检测代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

导入cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

segment＿video.load＿model(“pointrend＿resnet50.pkl”，检测速度＝”rapid”)

segment_video.process_camera(捕获，显示_bboxes＝True，每_second＝5帧，检查_fps＝True.显示_frames＝True)

帧名称＝”帧”，输出视频名称＝”输出视频.mp4″)

ins.load＿模型(“pointrend＿resnet50.pkl”，检测＿速度＝”快速”)

我们将处理实时相机馈送的检测速度设置为快速模式，推断速度为9fps。实时相机中自定义对象分割的代码

导入pixellib

从pixellib.torchbackend.instance导入实例分段

导入cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

分段_视频.加载_模型(“pointrend _ resnet50.pkl”)

target＿classes＝片段＿视频。选择＿target＿＿classes(人＝真)

segment＿video.process＿camera(捕获，显示＿bboxes＝True，每＿秒帧数＝5，片段＿目标＿类别＝目标＿类

show＿frames＝True，frame＿name＝”frame”，output＿video＿name=”output＿video.mp4″)

target＿classes＝片段＿视频。选择＿target＿＿classes(人＝真)

segment＿video.process＿camera(捕获，显示＿bboxes＝True，每＿秒帧数＝5，片段＿target＿classes＝目标＿class，显示＿＿帧＝True.帧＿name＝”frame”，输出＿video＿name=”output＿videos.mp4″)

调用函数select_target_classes选择要分割的目标对象。函数process_camera获得一个新的参数segment_target_classes，该参数可以从目标类中选择，并根据它们进行过滤以进行检测。

实时相机中的目标提取代码

导入pixellib

从pixellib.torchbackend.instance导入实例Segmentationimport cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

分段_视频.加载_模型(“pointrend _ resnet50.pkl”)

segment＿video.process＿camera(捕获，显示＿bboxes＝True，每＿秒帧数＝5，提取＿分段的＿对象＝True.保存＿提取的＿物体＝True)

show＿frames＝True，frame＿name＝”frame”，output＿video＿name=”output＿video.mp4″)segment＿video.process＿

摄像机(捕捉，显示_ bboxes＝True，每_秒帧数＝5，提取_分段_对象＝True.保存_提取的_对象＝True.显示_帧＝True和帧名称＝”帧”，输出_视频名称＝”输出_视频.mp4″)

process_camera函数有新参数extract_segmented_Object和save_extracted_Object，分别用于提取和保存分割对象。将extract_from_box添加到函数中，以从其边界框坐标中提取对象分割。

用于从实时相机中的框坐标中提取对象的代码

导入pixellib

从pixellib.torchbackend.instance导入实例Segmentationimport cv2

捕获＝cv2.VideoCapture(0)

分段_视频＝实例分段()

分段_视频.加载_模型(“pointrend _ resnet50.pkl”)

segment＿video.process＿camera(捕获，显示＿bboxes＝True，每＿秒帧数＝5，提取＿分段的＿对象＝True.从＿框中提取＿＝True)

保存＿提取的＿对象＝True，显示＿帧＝True.帧＿名称＝”frame”.输出＿视频＿名称=”output＿video.mp4″)

segment＿video.process＿camera(捕获，显示＿bboxes＝True，每＿秒帧数＝5，提取＿分段的＿对象＝True.从＿框中提取＿＝True保存＿提取的＿物体＝True显示＿帧＝True帧＿名称＝”帧”，输出＿video＿名称=”输出＿视频.mp4″)

将extract_from_box添加到函数中，以从其边界框坐标中提取对象分割。

在本文中，我们详细讨论了如何使用PixelLib Python版本对图像和实时相机中的对象执行准确.快速的图像分割和提取。我们还介绍了使用PointRend网络架构升级PixelLib，这使该库能够满足不断增长的需求，以平衡计算机视觉的精度和速度性能。

注意：PixelLib pytorch版本不支持自定义训练，使用PointRend的自定义训练将很快发布。