Halcon 第五章『模板匹配Matching』◆第5节：基于组件的模板匹配|Component-Based

一、介绍

基于组件的模板匹配是基于形状匹配的一种应用，也可以说是基于形状的模板匹配的加强版，加强的地方在于，这种方法允许模板中包含多个目标，并且允许目标之间存在相对运动（位移和旋转）。区别在于基于形状匹配使用一个ROI作为模板，基于组件匹配使用两个或两个以上的ROI作为组件ROI。同时这种方式不适用于尺寸缩放的情况。由于有多个ROI，且需要检测多个ROI之间的相对运动关系，因此这种方法与基于形状匹配相比要稍微复杂一点，且不适用于失焦图像和轻微变形的目标。

基于组件的模板匹配适用于组成部件之间有相对运动的物体，使用边缘特征定位物体，对于很多干扰因素不敏感，如光照变化、混乱无序等。其适用于多通道图像，不适用于纹理图像、聚焦不清的图像和形状变形的图像。

二、步骤

基于组件的模板匹配可以包含多个ROI，每个区域对应一个组件，并且组件之间还可以发生相对位置关系变化。因此，此方法的难点就在于确定组件之间的相对位置关系。

①提取组件的ROI。读取图像，提取组件。

提取组件有两种方式，一种是使用gen_rectangle1等算子，在图像中手动确定要检测的组件；

另一种是使用gen_initial_components算子自动提取组件。自动提取时要注意参数设置，防止将噪声等非关键部分也识别为组件，否则会对后面的匹配造成干扰。

Matching匹配 / Component-Based 组件匹配

自动提取一个组件模型的初始组件。

gen_initial_components(ModelImage : InitialComponents : ContrastLow, ContrastHigh, MinSize, Mode, GenericName, GenericValue : )

ModelImage：输入参数，输入图像，从中提取初始成分。

InitialComponents：输出参数，输出的组件区域。

ContrastLow：输入参数，输入提取样品图像的初始差别，下限阈值。默认 'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，范围＞0。

ContrastHigh：输入参数，输入提取样品图像的初始差别，上限阈值。默认 'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，范围ContrastHigh > 0 && ContrastHigh >= ContrastLow。

MinSize：输入参数，输入提取初始组件的最小尺寸。默认 'auto'，建议值【 'auto', 0, 5, 10, 20, 30, 40】，范围≥0。

Mode：输入参数，输入自动分割的类型。默认'connection'独立分割。

GenericName：输入参数，输入可选控制参数的名称。默认为空 []，范围【 'merge_distance', 'merge_fraction'】。

GenericValue：输入参数，输入可选控制参数的值。默认为空 []。

②训练组件之间的相对关系。如果组件位置已知，而相互之间的位置关系未知，可以使用多张图像构成一个训练样本集，并使用train_model_components算子对这些样本进行训练，以得到组件模型，还可以使用get_training_components算子查看训练结果。

Matching匹配 / Component-Based 组件匹配

训练基于组件的匹配的组件及其关系。

train_model_components(ModelImage, InitialComponents, TrainingImages : ModelComponents : ContrastLow, ContrastHigh, MinSize, MinScore, SearchRowTol, SearchColumnTol, SearchAngleTol, TrainingEmphasis, AmbiguityCriterion, MaxContourOverlap, ClusterThreshold : ComponentTrainingID)

ModelImage：输入参数，输入模型图像。

InitialComponents：输入参数，输入模型组件的区域，该东西为轮廓或者封闭的区域。

TrainingImages：输入参数，用于训练模型组件的训练图像，即示范样图像。

ModelComponents：输出参数，输出的结果组件区域。

ContrastLow：输入参数，输入提取样品图像的初始差别，下限阈值。默认'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，单位＞0。

ContrastHigh：输入参数，输入提取样品图像的初始差别，上限阈值。默认'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，范围ContrastHigh > 0 && ContrastHigh >= ContrastLow。

MinSize：输入参数，输入提取初始组件的最小尺寸。默认 'auto'，建议值，建议值【'auto', 0, 5, 10, 20, 30, 40】，范围≥0。

MinScore：输入参数，要找到的初始组件实例的最低分数，即在训练图中匹配的初始组件实例的最小得分。默认0.5，建议值【0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= MinScore && MinScore <= 1。

SearchRowTol：输入参数，在训练图中搜索初始组件，相对于初始组件位置增加的行搜索范围。默认-1，建议值【0, 10, 20, 30, 50, 100】，范围SearchRowTol == -1 || SearchColumnTol >= 0。

SearchColumnTol：输入参数，在训练图中搜索初始组件，相对于初始组件位置增加的列搜索范围。默认-1，建议值【0, 10, 20, 30, 50, 100】，范围SearchColumnTol == -1 || SearchColumnTol >= 0。

SearchAngleTol：输入参数，角度的搜索偏差。默认-1，建议值【0.0, 0.17, 0.39, 0.78, 1.57】，范围SearchAngleTol == -1 || SearchAngleTol >= 0。

TrainingEmphasis：输入参数，决定训练的重点是快速计算还是高鲁棒性。默认 'speed'，范围【 'reliability'以可靠为准, 'speed'以速度为准】

AmbiguityCriterion：输入参数，在训练图像中的初始组件模糊匹配的方式。默认'rigidity'，范围【 'distance'距离, 'distance_orientation'距离方向, 'orientation'方向, 'rigidity'严格】

MaxContourOverlap：输入参数，定义找到的两个轮廓模型多重叠的系数（初始组件合并的阈值）。默认0.2，建议值【0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= MaxContourOverlap && MaxContourOverlap <= 1。

ClusterThreshold：输入参数，输入聚集的初始组件模型的门槛。默认0.5，建议值【0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= ClusterThreshold && ClusterThreshold <= 1。

ComponentTrainingID：输出参数，输出组件模型的句柄。

Matching匹配 / Component-Based 组件匹配

get_training_components( : TrainingComponents : ComponentTrainingID, Components, Image, MarkOrientation : Row, Column, Angle, Score)

③创建模板，创建基于组件的匹配模板。如果组件之间的关系都已知，可以使用create_component_model算子创建模板；如果创建模板组件在训练过程之后，则可以使用create_trained_component_model算子创建模板。

Matching匹配 / Component-Based 组件匹配

准备一个基于显式指定的组件和关系进行匹配的组件模型。用于自定义区域的组件的模板创建

create_component_model(ModelImage, ComponentRegions : : VariationRow, VariationColumn, VariationAngle, AngleStart, AngleExtent, ContrastLowComp, ContrastHighComp, MinSizeComp, MinContrastComp, MinScoreComp, NumLevelsComp, AngleStepComp, OptimizationComp, MetricComp, PregenerationComp : ComponentModelID, RootRanking)

ModelImage：输入参数，输入图像，从中创建模型组件的形状模型。

ComponentRegions：输入参数，应该从其中创建模型组件的形状模型的输入区域。

VariationRow：输入参数，模型分量在行方向上的变化。建议值【 0, 1, 2, 3, 4, 5, 10, 20, 30, 40, 50, 100, 150】，范围≥0。

VariationColumn：输入参数，模型分量在列方向上的变化。建议值【 0, 1, 2, 3, 4, 5, 10, 20, 30, 40, 50, 100, 150】，范围≥0。

VariationAngle：输入参数，角度的搜索偏差。建议值【0.0, 0.017, 0.035, 0.05, 0.07, 0.09, 0.17, 0.35, 0.52, 0.67, 0.87】，范围≥0。

AngleStart：输入参数，输入匹配的起始角度。默认-0.39，建议值【-3.14, -1.57, -0.79, -0.39, -0.20, 0.0】。

AngleExtent：输入参数，输入匹配的角度范围。默认0.79，建议值【 6.28, 3.14, 1.57, 0.79, 0.39】，范围≥0。

ContrastLowComp：输入参数，输入样品图像的初始差别，下限阈值。默认'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，范围＞0。

ContrastHighComp：输入参数，输入样品图像的初始差别，上限阈值。默认'auto'，建议值【 'auto', 10, 20, 30, 40, 60, 80, 100, 120, 140, 160】，范围ContrastHighComp > 0 && ContrastHighComp >= ContrastLowComp。

MinSizeComp：输入参数，输入该模型中轮廓区域的最小尺寸。默认 'auto'，建议值【 'auto', 0, 5, 10, 20, 30, 40】，范围≥0。

MinContrastComp：输入参数，被搜索图像中组件的最小差别。默认'auto'，建议值【'auto', 10, 20, 20, 40】，范围MinContrastComp <= ContrastLowComp && MinContrastComp >= 0。

MinScoreComp：输入参数，要找到的组件实例的最小得分，即与该模型的最小匹配值（质量方面）。默认0.5，建议值【0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= MinScoreComp && MinScoreComp <= 1。

NumLevelsComp：输入参数，组件的最大金字塔层数。默认 'auto'，范围【1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'auto'】。

AngleStepComp：输入参数，输入匹配旋转角度(分辨率)的步长。默认 'auto'，建议值【 'auto', 0.0175, 0.0349, 0.0524, 0.0698, 0.0873】，范围≥0。

OptimizationComp：输入参数，用于对组件进行优化，设置模板优化和模板创建方法，减少匹配的模型的点数来提高运行效率。默认 'auto'，范围【 'auto', 'none', 'point_reduction_high', 'point_reduction_low', 'point_reduction_medium'】。

MetricComp：输入参数，设置匹配方法。默认 'use_polarity'，范围【 'ignore_color_polarity', 'ignore_global_polarity', 'ignore_local_polarity', 'use_polarity'】。

PregenerationComp：输入参数，是否重新生成该组件。默认 'false'，范围【 'false', 'true'】。

ComponentModelID：输出参数，输出组件模型的句柄。

RootRanking：输出参数，输出初始组件模型的等级排名。

Matching匹配 / Component-Based 组件匹配

根据训练过的部件，准备部件模型进行匹配。（基于组件模型来创建一个组件匹配模型）用于训练过的模板创建

create_trained_component_model( : : ComponentTrainingID, AngleStart, AngleExtent, MinContrastComp, MinScoreComp, NumLevelsComp, AngleStepComp, OptimizationComp, MetricComp, PregenerationComp : ComponentModelID, RootRanking)

ComponentTrainingID：输入参数，输入组件模型句柄。

AngleStart：输入参数，输入匹配的起始角度。默认-0.39，建议值【-3.14, -1.57, -0.79, -0.39, -0.20, 0.0】。

AngleExtent：输入参数，输入匹配的角度范围。默认0.79，建议值【 6.28, 3.14, 1.57, 0.79, 0.39】，范围≥0。

MinContrastComp：输入参数，被搜索图像中组件的最小差别。默认 0.79，建议值【 6.28, 3.14, 1.57, 0.79, 0.39】，范围≥0。

NumLevelsComp：输入参数，组件的最大金字塔层数。默认 'auto'，默认 'auto'，范围【1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'auto'】。

AngleStepComp：输入参数，输入匹配选择角度的步长。默认 'auto'，建议值【 'auto', 0.0175, 0.0349, 0.0524, 0.0698, 0.0873】，范围≥0。

MetricComp：输入参数，设置匹配方法。默认 'use_polarity'，范围【 'ignore_color_polarity', 'ignore_global_polarity', 'ignore_local_polarity', 'use_polarity'】。

PregenerationComp：输入参数，是否重新生成该组件（如果=true，则完成组建的形状模型的预生成）。默认 'false'，范围【 'false', 'true'】。

ComponentModelID：输出参数，输出组件模型的句柄。

RootRanking：输出参数，输出初始组件模型的等级排名。

④寻找组件并确定相对位置关系。匹配的过程通常是使用find_component_model算子来搜索目标中的多个组件。匹配算法使用的是类似于树型的结构，因此find_component_model算子中应指明树的根节点RootComponent，然后由根节点开始搜索其他的关联节点。

Matching匹配 / Component-Based 组件匹配

找到图像中组件模型的最佳匹配。

find_component_model(Image : : ComponentModelID, RootComponent, AngleStartRoot, AngleExtentRoot, MinScore, NumMatches, MaxOverlap, IfRootNotFound, IfComponentNotFound, PosePrediction, MinScoreComp, SubPixelComp, NumLevelsComp, GreedinessComp : ModelStart, ModelEnd, Score, RowComp, ColumnComp, AngleComp, ScoreComp, ModelComp)

Image：输入参数，输入需要匹配的图像。

ComponentModelID：输入参数，组件匹配模型句柄。

RootComponent：输入参数，根组件匹配模型的索引。建议值【0, 1, 2, 3, 4, 5, 6, 7, 8】。

AngleStartRoot：输入参数，根组件匹配模型的起始角度。默认-0.39，建议值【-3.14, -1.57, -0.79, -0.39, -0.20, 0.0】。

AngleExtentRoot：输入参数，根组件匹配模型的角度范围。默认0.79，建议值【 6.28, 3.14, 1.57, 0.79, 0.39, 0.0】，范围≥0。

MinScore：输入参数，匹配的最小得分，即该模型的最小匹配值（质量方面）。默认0.5，建议值【0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= MinScore && MinScore <= 1。

NumMatches：输入参数，最大的匹配目标组件数量。默认1，建议值【 0, 1, 2, 3, 4, 5, 10, 20】。

MaxOverlap：输入参数，匹配目标组件最大重叠的部分的系数。默认0.5，建议值【0.0找到的目标区域不能存在重叠, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0所有找到的目标区域都要返回】，范围0 <= MaxOverlap && MaxOverlap <= 1。

IfRootNotFound：输入参数，当没有匹配到根组件的时候需要执行的操作。默认'stop_search'，范围【 'select_new_root'选择新目录, 'stop_search'停止搜索】。

IfComponentNotFound：输入参数，没有匹配到根组件以外的组件的时候执行的操作。默认 'prune_branch'，范围【 'prune_branch'放弃搜索, 'search_from_best'根据已找到的匹配分数最高的组件元素来再次查找, 'search_from_upper'根据已找到的组件元素，再次查找】。

PosePrediction：输入参数，对未找到的组件进行姿态预测。默认'none'，范围【 'from_all'从全部, 'from_neighbors'从邻近, 'none'】。

MinScoreComp：输入参数，找到的组件实例的最小得分，即与匹配模型最小匹配值（质量方面）。默认0.5，建议值【0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围0 <= MinScoreComp && MinScoreComp <= 1。

SubPixelComp：输入参数，是否使用亚像素组件查找。 'least_squares'，范围【'none', 'interpolation', 'least_squares', 'least_squares_high', 'least_squares_very_high', 'max_deformation 1', 'max_deformation 2', 'max_deformation 3', 'max_deformation 4', 'max_deformation 5', 'max_deformation 6'】

NumLevelsComp：输入参数，输入组件的金字塔的最大层数。默认0，范围【 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10】。

GreedinessComp：输入参数，贪婪度（查找速度系数）。默认0.9，建议值【0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0】，范围 0 <= GreedinessComp && GreedinessComp <= 1。0.0安全但速度慢；1.0快而可能匹配失败。

ModelStart：输出参数，输出找到的组件模型对应在组件（元组）的起始索引。

ModelEnd：输出参数，输出找到的组件模型对应在组件（元组）的结束索引。

Score：输出参数，输出目标组件的匹配得分。

RowComp：输出参数，输出目标组件的y值行坐标。

ColumnComp：输出参数，输出目标组件的x值列坐标。

AngleComp：输出参数，输出目标组件的角度。

ScoreComp：输出参数，输入目标组件的匹配得分（匹配值）。

ModelComp：输出参数，输出找到的组件的索引。

⑤清除模型。匹配结束后，使用clear_component_model算子将模板清除，并释放内存资源。

Matching匹配 / Component-Based 组件匹配

释放组件模型的内存。

clear_component_model( : : ComponentModelID : )

****获取指定路径下的所有图像文件
list_image_files ('label', 'default', [], SearchImageFiles)
****regexp_select选择符合条件的文件，输出SearchImageFiles
SearchImageFiles := regexp_select(SearchImageFiles,'(label_[0-9]+.png)|(label_training_)')
****读取label_model图像
read_image (Image, 'label/label_model')
*****************第一步：提取组件的ROI。读取图像，提取组件。*****************
****利用矩形框选出具体的区域，并显示出模型图像ModelImage
gen_rectangle1 (ModelRegion, 119, 106, 330, 537)
reduce_domain (Image, ModelRegion, ModelImage)
****从label_model图像中自动提取出初始组件，输出InitialComponents组件区域
gen_initial_components (ModelImage, InitialComponents, 40, 40, 20, 'connection', [], [])
****创建一个名为TrainingImages的空对象元组。
gen_empty_obj (TrainingImages)
for Index := 1 to 5 by 1
    ****按个读取label文件夹内名为label_training_1、label_training_2、label_training_3、label_training_4、label_training_5的图片
    read_image (TrainingImage, 'label/label_training_' + Index)
    ****将读取到的图像放入到名为TrainingImages的元组内
    concat_obj (TrainingImages, TrainingImage, TrainingImages)
endfor
**********************第二步：训练组件之间的相对关系。**********************
****⑴输入初始图像ModelImage，⑵输入InitialComponents初始组件区域，⑶输入TrainingImages作为示范图像。进行训练，输出ModelComponents和ID。
train_model_components (ModelImage, InitialComponents, TrainingImages, ModelComponents, 40, 40, 20, 0.85, -1, -1, rad(15), 'reliability', 'rigidity', 0.2, 0.5, ComponentTrainingID)
stop ()
******************第三步：创建模板，创建基于组件的匹配模板。******************
create_trained_component_model (ComponentTrainingID, -rad(30), rad(60), 10, 0.8, 'auto', 'auto', 'none', 'use_polarity', 'false', ComponentModelID, RootRanking)
****释放组件训练结果的内存。
clear_training_components (ComponentTrainingID)
stop ()
********************第四步：寻找组件并确定相对位置关系。********************
for Index := 0 to |SearchImageFiles| - 1 by 1
    read_image (SearchImage, SearchImageFiles[Index])
    find_component_model (SearchImage, ComponentModelID, RootRanking, -rad(30), rad(60), 0.5, 0, 0.5, 'stop_search', 'prune_branch', 'none', 0.6, 'least_squares', 4, 0.9, ModelStart, ModelEnd, Score, RowComp, ColumnComp, AngleComp, ScoreComp, ModelComp)
    dev_display (SearchImage)
    for Match := 0 to |ModelStart| - 1 by 1
        dev_display (SearchImage)
        get_found_component_model (FoundComponents, ComponentModelID, ModelStart, ModelEnd, RowComp, ColumnComp, AngleComp, ScoreComp, ModelComp, Match, 'false', RowCompInst, ColumnCompInst, AngleCompInst, ScoreCompInst)
        dev_display (FoundComponents)
    endfor
    disp_message (200000, 'Found components in image ' + (Index + 1) + ' of 15', 'window', 12, 12, 'black', 'true')

    if (Index < |SearchImageFiles| - 1)
        disp_continue_message (200000, 'black', 'true')
        stop ()
    endif
endfor
********************第五步：清除模型，并释放内存资源。********************
clear_component_model (ComponentModelID)

第二步训练，输出ModelComponents和ComponentTrainingID

对SearchImageFiles内的图片开始逐个匹配—label_01.png

dev_close_window ()
*读取参考图像，这里读取的是单通道灰度图像
read_image (ModelImage, 'data/bolts-0') 
*设置显示图像、绘制线条等窗口参数
dev_open_window_fit_image (ModelImage, 0, 0, -1, -1, WindowHandle)
dev_display (ModelImage)
dev_set_draw ('margin')
dev_set_line_width(3)
stop ()
*定义各个组件, 选取各个组件的ROI区域
gen_rectangle1 (Rectangle1, 140, 71, 279, 168)
gen_rectangle1 (Rectangle2, 181, 281,285, 430)
gen_circle (Circle, 106, 256, 60)
*将所有组件放进一个名为ComponentRegions的Tuple中
concat_obj (Rectangle1, Rectangle2, ComponentRegions)
concat_obj (ComponentRegions, Circle, ComponentRegions)
*显示参考图像，以及选择的各个组件区域。核对区域选择是否理想
dev_display (ModelImage)
dev_display (ComponentRegions)
stop ()
*创建基于组件的模板，返回模板句柄ComponentModelID
create_component_model (ModelImage, ComponentRegions, 20, 20, rad(25), 0, rad(360), 15, 40, 15, 10, 0.8, 3, 0, 'none', 'use_polarity', 'true', ComponentModelID, RootRanking)
*读取测试图像，该测试图像相对于参考图像有一定的位移和旋转。
read_image (SearchImage, 'data/bolts-1')
*在参考图像模板的基础上，进行基于基于组件的匹配
find_component_model (SearchImage, ComponentModelID, RootRanking, 0, rad(360), 0.5, 0, 0.5, 'stop_search', 'search_from_best', 'none', 0.8, 'interpolation', 0, 0.8, ModelStart, ModelEnd, Score, RowComp, ColumnComp, AngleComp, ScoreComp, ModelComp)
*显示测试图像
dev_display (SearchImage)
*对每一个检测到的组件实例进行可视化的显示
for Match := 0 to |ModelStart| - 1 by 1
	dev_set_line_width (4)
	*获得每个组件的实例和位移旋转等参数
	get_found_component_model (FoundComponents, ComponentModelID, ModelStart, ModelEnd, RowComp, ColumnComp, AngleComp, ScoreComp, ModelComp, Match, 'false', RowCompInst, ColumnCompInst, AngleCompInst, ScoreCompInst)
	dev_display (FoundComponents)
endfor
stop ()
*匹配结束，释放模板资源
clear_component_model (ComponentModelID)