Correspondance de modèle basée sur la forme (basée sur la forme)

C'est ce qu'on appelle la correspondance basée sur le gradient de direction des bords et c'est l'algorithme de correspondance de modèles le plus couramment utilisé et le plus avancé.

(1) Pensées fondamentales

Utilisation de la corrélation de gradient du bord de l'objet comme critère de correspondance

(2) Principe

Extrayez les caractéristiques de bord dans le ROI, créez un modèle basé sur des informations en niveaux de gris et générez un modèle de pyramide d'images à plusieurs niveaux basé sur les exigences de taille et de clarté du modèle.

Recherchez ensuite l'image modèle couche par couche dans la couche de pyramide d'images de haut en bas jusqu'à ce que la couche inférieure soit recherchée ou qu'un résultat de correspondance confirmé soit obtenu.

(3) Conditions d'utilisation

Cette méthode utilise les caractéristiques des contours pour localiser les objets et est insensible à de nombreux facteurs d'interférence, tels que les changements d'éclairage et d'échelle de gris de l'image. Elle peut même prendre en charge des modèles présentant une perte de contour locale, des scènes encombrées, du bruit, une floue et une légère déformation.

De plus, il peut même prendre en charge la recherche simultanée de plusieurs modèles.

Mais il ne convient pas aux situations de rotation et de mise à l'échelle importantes.

(4) Opérateur de correspondance de forme

 /*
 1.创建形状模型：create_shape_model()
 2.寻找形状模型：find_shpae_model()
 3.释放形状模型：clear_shape_model()
 */

(5) Exemples

1. Créez la zone ROI et préparez l'image du modèle pour créer le modèle (le modèle peut être enregistré après l'avoir créé)

Formes standards : draw_rectangle1/2, draw_circle, draw_ellipse, draw_line

Formes arbitraires : draw_region, draw_polygon

Générer un retour sur investissement standard : gen_rectangle1/2, gen_circle, gen_ellipse, gen_region_line

Créer une AOI via XLD : gen_region_contour_xld, gen_region_polygon_xld

Utilisez Area_center() pour trouver le centre de cette zone ROI

Obtenez cette zone de retour sur investissement à partir de l'image via réduire_domain()

2. Correction du retour sur investissement, améliorant la qualité de l'image grâce au prétraitement pour trouver un modèle d'image plus approprié

Fonctions de correction : érosion (réduire le retour sur investissement), dilatation (élargir le retour sur investissement), shape_trans (conversion de forme), limite (limite au niveau du pixel), move_region (déplacer la région vers un nouvel emplacement)

Combinaison : intersection, différence, union2 (union de deux zones)

3. Créez des modèles directement

 create_shape_model(Template , // 模板图像
                    NumLevels, // 金字塔层数
                    AngleStart, // 起始角度
                    AngleExtent, // 角度范围
                    AngleStep, // 角度步长
                    Optimization, // 设置模板优化和模板创建方法
                    Metric, // 匹配方法设置
                    Contrast, // 模板中前景与背景的对比度
                    MinContrast， // 被查找图片的最小对比度
                    ModelID） // 模板ID
 // 可缩放比例
 create_scaled_shape_model(Template : : NumLevels, AngleStart, AngleExtent, AngleStep, ScaleMin, ScaleMax, ScaleStep, Optimization, Metric, Contrast, MinContrast : ModelID)
                    
 create_scaled_shape_model (ImageReduced, 5, rad(-45), rad(90), 0, 0.8, 1.0, 0, ['none','no_pregeneration'], 'ignore_global_polarity', 40, 10, ModelID)

Utilisez l' opérateur détermine_shape_model_params pour obtenir le nombre de couches de pyramide , puis utilisez l'opérateur inspect_shape_model pour tester si la valeur de contraste est raisonnable.

Après avoir créé le modèle, vous devez surveiller le modèle , ce qui est effectué à l'aide de l' opérateur inspect_shape_model pour détecter l'applicabilité des paramètres et trouver les paramètres appropriés.

Une fois l'opérateur exécuté, l'image de classement pyramidal des paramètres prédéfinis sera affichée. Vous pouvez juger si la sélection des paramètres est raisonnable en fonction de vos besoins.

  inspect_shape_model(Image : // 输入参数，输入图像
                     ModelImages, // 输出参数，输出图像基于金字塔的影像
                     ModelRegions : // 输出参数，输出模型区域
                     NumLevels, // 输入参数，使用的金字塔层数。默认4，范围1~10
                     Contrast : ) // 输入参数，设置对比度。默认30，参考10，20，30，40，60，80，100，120，140，160

（1）NumNiveaux

Cela commence par le premier niveau et ajoute +1 à chaque niveau.

Plus la pyramide est petite, plus les informations sont détaillées et le positionnement précis, mais cela prend également plus de temps ; plus la pyramide est grande, moins il faut de temps pour trouver une correspondance.

De plus, il faut s'assurer que l'image de premier niveau contient suffisamment d'informations (au moins quatre points). Si la pyramide est trop grande et que le modèle n'est pas facile à identifier, vous devez définir les paramètres MinScore et Greediness dans la fonction find_shape_model plus bas (faites attention à la solution ici !!!)

S'il y a trop peu de messages au niveau le plus élevé de la pyramide, l'algorithme réduira automatiquement le nombre de niveaux de la pyramide.

S'il y a trop peu d'informations en bas de la pyramide, la fonction signalera une erreur

S'il est défini sur auto, l'algorithme calculera automatiquement le nombre de couches de pyramide . Nous pouvonsvisualiser le nombre de couches de pyramide via la fonction get_shape_model_params .

 // 根据创建的模型ID来查看形状模型的参数
 get_shape_model_params( : : ModelID : NumLevels, AngleStart, AngleExtent, AngleStep, ScaleMin, ScaleMax, ScaleStep, Metric, MinContrast)
 // ScaleMin, ScaleMax, ScaleStep是模型的最小比例、最大比例、缩放步长

（2）Contraste

Le contraste est utilisé pour mesurer la différence de valeur de gris locale entre la cible et l'arrière-plan et entre les différentes parties de la cible.

Quand 1 élément : 128, contraste, extraire les bords directement

Lorsqu'il y a 2 éléments : [100, 128], cela signifie utiliser l'algorithme de seuil d'hystérésis pour segmenter et extraire les arêtes.

Lorsqu'il y a 3 éléments : [100, 128, 10], les deux premiers paramètres sont identiques à 2, et le dernier paramètre indique que la longueur minimale du bord extrait est de 10

Le seuil de contraste peut être déterminé automatiquement à l'aide de la fonction déterminer_shape_model_params , ou l'effet peut être vérifié à l'aide de la fonction inspect_shape_mode avant d'appeler create_shape_model

 determine_shape_model_params(Template, // 模板 
                              ‘auto’, // 金字塔层数
                              0, // 起始角度
                              rad(360), // 角度范围
                              0.9, // 缩小范围
                              1.1, // 放大范围
                              ‘auto’, // 减少像素的方法
                              ‘use_polarity’, // 极性
                              ‘auto’, // 对比度
                              ‘auto’, // 最小对比度
                              'all', // 需要自动确定的参数
                              ParameterName, // Name of values
                              ParameterValue) // Values

（3）AngleStart、AngleExtent、AngleStep

La sélection d'AngleStep est basée sur la taille de la cible. Si l'image modèle est trop petite, elle ne peut pas générer de nombreuses images avec différents angles discrets. Par conséquent, pour les images modèles plus petites, AngleStep doit être défini sur une valeur plus grande .

Si AngleExtent n'est pas un multiple entier de AngleStep, AngleStep sera modifié en conséquence.

AngleÉtape

Critères de sélection : Plus le modèle est grand, plus le pas d'angle est petit ; plus le modèle est petit, plus le pas d'angle est grand.

Vitesse et mémoire : Plus la taille du pas est petite, plus la mémoire est occupée et plus la vitesse de positionnement est lente.

S'il n'y a pas d'exigences particulières, sélectionnez « auto » pour laisser le système faire le meilleur choix et définir automatiquement un pas d'angle approprié en fonction de la taille du modèle.

（4）Optimisation

Configurer les méthodes d'optimisation et de création de modèles

Certains modèles contiennent trop de pixels, ce qui entraîne une taille excessive du modèle, une augmentation du temps d'exécution et des besoins en mémoire accrus.

Le paramètre Optimisation permet de réduire ces points. Dans les mêmes conditions, le temps d'exécution est à son tour réduit.

aucun, pas de réduction de pixels

point_reduction_low, environ un demi-point

point_reduction_medium, environ 1/3

point_reduction_high, environ 1/4

Pour les images modèles particulièrement volumineuses, il est très utile de définir le paramètre Optimisation sur une valeur autre que « aucun » ; pour les modèles plus petits, réduire le nombre de points du modèle n'améliore pas la vitesse de recherche.

Si le nombre de points du modèle diminue , le paramètre Greediness doit être défini sur une valeur relativement petite dans la fonction find_shape_model , telle que : 0,7, 0,8

Si l'optimisation est définie sur « auto », create_shape_model détermine automatiquement le nombre de points pour le modèle.

En plus de réduire les pixels, ce paramètre peut également contrôler la manière dont les modèles sont créés pour choisir la priorité mémoire ou la priorité vitesse.

La deuxième valeur peut être facultative parmi les deux suivantes

'prégénération', le modèle est créé à l'avance, sacrifiant la mémoire pour la vitesse de recherche

'no_pregénération', crée les données nécessaires uniquement lors de la recherche, prend moins de mémoire
La valeur par défaut est le paramètre dans le système
 set_system('pregenerate_shape_models','true'/'false')
S'il n'est pas défini, la valeur par défaut est
 set_system('pregenerate_shape_models','false')

（5）Métrique

Conditions de correspondance des modèles dans les images

use_polarity : les objets de l'image ont le même contraste que le modèle (le premier plan est clair et l'arrière-plan est sombre, donc seuls les objets plus clairs que l'arrière-plan peuvent être trouvés)

ignore_global_polarity : La cible peut également être trouvée lorsque le contraste entre les deux est complètement opposé (la cible peut également être trouvée si la cible est plus sombre que l'arrière-plan)

ignore_local_polarity : Le modèle peut être trouvé même si le contraste local change (ce mode est très utile lorsque la cible contient une partie de gris moyen, une partie plus claire et une partie plus sombre)

Étant donné que le temps d'exécution de la fonction find_shape_model augmente considérablement dans ce mode, la meilleure approche consiste à utiliser create_shape_model pour créer plusieurs modèles qui reflètent les changements de contraste possibles de la cible, et à utiliser find_shape_models pour les faire correspondre.

（6）Contraste Min

Pour séparer le modèle du bruit de l'image, si la plage de fluctuation de la valeur de gris est de 10, alors MinContrast = 10

Les bords de l'image modèle ne sont pas nécessairement bénéfiques. Le bruit et la texture provoqueront des bords nuisibles. Les bords nuisibles entraîneront un positionnement inexact ou une recherche erronée, des scores erronés et augmenteront légèrement le temps de recherche.

Le paramètre MinContrast est utilisé pour réduire les bords « nuisibles » lors de la recherche de modèles.

Cette valeur peut être déterminée via la fonctionestimate_noise, la fonction inspect_shape_model et l'assistant

(7) Remarque : créez des modèles via des fichiers Dxf (Format Exchange File)

Les modèles peuvent être créés directement à partir des contours des pixels

create_scaled_shape_model_xld
create_aniso_shape_model_xld

4. Il est nécessaire d'obtenir les grandes lignes de ce modèle pour une correspondance ultérieure.

 get_shape_model_contours(ModelContours, // 输出形状模型的轮廓表示
                          ModelID, // 模型句柄
                          Level) // 金字塔层数

5. Correspondance de modèles pour obtenir des informations sur la position, l'angle, la valeur d'échelle et le score

Trouvez le modèle le mieux correspondant dans l'image et renvoyez la longueur, la largeur et l'angle de rotation d'une instance de modèle

 find_shape_model(Image, // 搜索图像
                  ModelID, // 模板句柄
                  AngleStart, // 搜索时的起始角度
                  AngleExtent, // 搜索时的角度范围，必须与创建模板时的有交集
                  MinScore, // 最小匹配值，输出的匹配的得分Score大于该值
                  NumMatches, // 定义要输出的匹配的最大个数
                  MaxOverlap, // 当找到的目标存在重叠时，且重叠大于该值时选择一个好的输出
                  SubPixel, // 计算精度的设置，五种模式，多选2，3
                  NumLevels, // 搜索时金字塔的层数
                  Greediness, // 贪婪度，搜索启发式，一般都设为0.9，越高速度快,容易出现找不到的情况
                  Row, Column, Angle, Score) // 输出匹配位置的行和列坐标、角度、得分（模板在搜索图像中可见比例的近似测量，如果模板的一半被遮挡，该值就不能超过0.5）

Les paramètres affectent la vitesse et la précision de la correspondance

（1）MinScore

Quel est le coefficient de qualité minimum requis pour la correspondance du modèle afin de trouver le modèle dans l'image ?

Plus le MinScore est grand, plus il est similaire et plus la recherche sera rapide.

Si le modèle n'est pas masqué dans l'image, MinScore peut être défini jusqu'à 0,8 ou même 0,9.

（2）NumMatches

Trouver le nombre maximum de modèles sur l'image

Si le nombre de cibles avec un coefficient de qualité de correspondance supérieur à MinScore est supérieur à NumMatches, seuls les emplacements cibles NumMatches avec les meilleurs coefficients de qualité seront renvoyés. Si les cibles correspondantes trouvées ne sont pas suffisamment de NumMatches, alors seules les quelques cibles trouvées seront renvoyées.

Le paramètre MinScore est meilleur que NumMatche

（3）Chevauchement maximum

Le paramètre MaxOverlap est compris entre 0 et 1, et définit le coefficient de recouvrement maximum entre les deux zones cibles trouvées, afin qu'elles puissent être restituées comme deux zones cibles différentes.

Si les deux zones cibles trouvées se chevauchent et sont plus grandes que MaxOverlap, seule celle ayant le meilleur effet est renvoyée.

La méthode de calcul du chevauchement est basée sur la recherche du plus petit rectangle englobant dans n'importe quelle direction de la zone cible (voir smallest_rectangle2). Si MaxOverlap=0, les zones cibles trouvées ne peuvent pas se chevaucher. Si MaxOverlap=1, toutes les zones cibles trouvées doivent être renvoyées.

（4）Sous-Pixel

Déterminer si la cible trouvée est extraite avec une précision inférieure au pixel, généralement réglée sur interpolation

Modèle de contrôle de précision

none : aucun sous-pixel n'est utilisé, l'erreur maximale est d'un demi-pixel

interpolation : la position et l'angle sont tous deux précis au sous-pixel. Dans ce mode, la position du modèle est interpolée dans la fonction de coefficient de masse, ce qui ne prend pratiquement aucun temps de calcul et permet d'obtenir une précision suffisamment élevée.

lesast_squares, lesast_squares_high, lesast_squares_very_high : précision sous-pixel des moindres carrés

L'impact des différents modes sur le temps d'exécution : les deux premiers prennent le même temps, mais la méthode des moindres carrés prend plus de temps

Ce paramètre peut affecter les résultats suivants : Position, Angle, Mise à l'échelle

（5）NumNiveaux

Si NumLevels=0, utilisez le nombre de niveaux de la pyramide lors de la création du modèle

NumLevels peut également contenir un deuxième paramètre, qui définit le nombre minimum de niveaux de pyramide auxquels les modèles correspondants sont trouvés.

Par exemple, NumLevels=[4,2] signifie que la correspondance commence au quatrième niveau de la pyramide et la correspondance se trouve au deuxième niveau de la pyramide (le plus bas est fixé à 1)

Vous pouvez utiliser cette méthode pour réduire le temps d'exécution de la correspondance, mais la précision de la position dans ce mode est inférieure à celle du mode normal. Le mode dit normal correspond au bas de la pyramide.

Par conséquent, si une plus grande précision est requise, SubPixel doit être défini sur au moins « least_squares ». Si le niveau le plus bas de la pyramide est trop grand, la précision souhaitée risque de ne pas être obtenue ou une région de correspondance incorrecte peut être trouvée. En effet, les modèles situés aux niveaux supérieurs de la pyramide ne sont pas suffisamment spécifiques pour trouver les meilleures correspondances de modèles fiables. Dans ce cas, le nombre minimum de niveaux de pyramide doit être fixé à la valeur minimale

（6）La gourmandise

Ce paramètre est utilisé pour l'accélération du positionnement, ce qui affecte grandement la vitesse de recherche.

S'il vaut 0, il s'agit d'une recherche heuristique ; s'il vaut 1, il s'agit d'une recherche non sécurisée.

Plus la valeur est petite, plus la vitesse est lente ; plus la valeur est élevée, plus le risque de perdre la cible est grand.

Valeur recommandée : 0,7 ~ 0,9

6. Convertir après la correspondance du modèle (pas parfait)

（1）vecteur_angle_to_rigid()

Calcule une transformation affine d'un corps rigide à partir d'un point et d'un angle

（2）affine_trans_contour_xld()

 for i:=0 to |Score|-1 by 1
     // 得到对应匹配目标的旋转矩阵
     vector_angle_to_rigid (0, 0, 0, Row[i], Column[i], Angle[i], HomMat2DRotate)
     // 在旋转矩阵的基础上添加缩放量，生成新的矩阵
     hom_mat2d_scale (HomMat2DRotate, Scale[i], Scale[i], Row[i],Column[i], HomMat2DScale)
     // 矩阵变换（xld基础上）
     affine_trans_contour_xld (ModelContours, ContoursAffineTrans, HomMat2DScale)
     // xld转换成region
     gen_region_contour_xld (ContoursAffineTrans, Region, 'filled')
     // 对区域，生成最小外接矩形
     smallest_rectangle1 (Region, Row1, Column1, Row2, Column2)
     // 使用绿色矩形框，框选匹配结果
     dev_set_color ('green')
     disp_rectangle1 (WindowHandle, Row1[0], Column1[0], Row2[0], Column2[0])
     // 使用红色勾画匹配结果轮廓
     dev_set_color ('red')
     dev_display (ContoursAffineTrans)
     // 显示各匹配结果提示语
     disp_message (WindowHandle, '第'+(i+1)+'个', 'window', Row1[0]-30, (Column1[0]+Column2[0])/2-10, 'green', 'false')
 endfor

7. Comment accélérer la correspondance des recherches ?

Tant que la correspondance est réussie, augmentez au maximum la valeur du paramètre MinScore

Augmentez la valeur de Greediness jusqu'à ce qu'un match échoue, tout en diminuant la valeur MinScore si nécessaire

Lors de la création d'une image, augmentez le nombre de niveaux de pyramide

Limitez la plage de rotation et la plage de taille autorisées, et ajustez les paramètres correspondants lors de l'appel de find_shape_model()

Essayez de limiter la valeur de la zone de retour sur investissement de la recherche

8. Exemples

(1) Lignes de quadrillage

 // 关闭程序计数器,变量更新,图像窗口更新
 dev_update_off ()
 dev_close_window ()
 
 // 读取模版图像
 read_image (Image, 'wafer/wafer_mirror_dies_01')
 dev_open_window_fit_image (Image, 0, 0, -1, -1, WindowHandle)
 set_display_font (WindowHandle, 16, 'mono', 'true', 'false')
 // 定义输出区域,轮廓的线宽
 dev_set_line_width (3)
 dev_display (Image)
 
 // 这个过程会在屏幕右下角显示“Click 'Run' to continue”。
 disp_continue_message (WindowHandle, 'black', 'true')
 stop()
 
 // 创建剪切矩形ROI作为模板图像
 gen_rectangle1 (Rectangle, 362, 212, 414, 262)
 reduce_domain (Image, Rectangle, ImageReduced)
 
 // 根据金字塔数和对比度获取输入图像的金字塔图像、金字塔区域
 inspect_shape_model (ImageReduced, ModelImages, ModelRegions, 4, 30)
 // 显示金字塔各层级的图像，以检查层数的合理性
 dev_display(ModelRegions)
 area_center(ModelRegions, AreaModelRegions, RowModelRegions, ColumnModelRegions)
 count_obj(ModelRegions, Number)
 // 确定金字塔的层级
 for i := 1 to Number by 1
     if(AreaModelRegions[i-1]>=10)
         NumLevels := i
     endif
 endfor
 
 // 创建形状模版
 create_shape_model (ImageReduced, NumLevels, rad(0), rad(1), 'auto', 'auto', 'use_polarity', 'auto', 'auto', ModelID)
 // 获得模型轮廓，中心点在原点位置
 get_shape_model_contours (ModelContours, ModelID, 1)
 
 // 开始在搜索图像中搜索模版
 for Index := 1 to 4 by 1
     read_image (Image, 'wafer/wafer_mirror_dies_' + Index$'02')
     // 计算当前过去的时间,单位是秒
     count_seconds (S1)
     // 使用匹配算子进行形状模板匹配
     find_shape_model (Image, ModelID, rad(0), rad(1), 0.5, 0, 0.0, 'least_squares', 2, 0.5, Row, Column, Angle, Score)
     // 计算当前过去的时间,单位是秒
     count_seconds (S2)
     Runtime := (S2 - S1) * 1000
 
     // 生成十字对象
     gen_cross_contour_xld (Cross, Row, Column, 6, rad(45))
     // 显示匹配结果，将匹配得到的实例以形状轮廓的形式绘制出来
     dev_display_shape_matching_results (ModelID, 'lime green', Row, Column, Angle, 1, 1, 0)
     // 设置输出对象的颜色
     dev_set_color ('orange')
     // 显示图像
     dev_display (Image)
     // 显示十字
     dev_display (Cross)
     stop ()
 
 endfor
 get_system ('border_shape_models', model)
 //  匹配结束，释放模板资源
 clear_shape_model (ModelID)

Traitement des limites
- set_system('border_shape_models','false')
- Le modèle doit être dans le ROI
- Les parties proches des bords seront rognées
- set_system('border_shape_models','true')
- Le modèle peut être partiellement en dehors du ROI
- Remarque : les points seront réduits

(2) Panneaux de protection de l'environnement.

 dev_update_off ()
 dev_close_window ()
 
 // 定位模板
 // 读取图像
 read_image (Image, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/一个环保标志.png')
 // 获取图像的宽高
 get_image_size (Image, Width, Height)
 // 以合适的尺寸打开图像
 dev_open_window_fit_size (0, 0, Width, Height, -1, -1, WindowHandle)
 //显示图像、字体、填充方式、颜色、字宽
 dev_display (Image)
 set_display_font (WindowHandle, 16, 'mono', 'true', 'false')
 dev_set_draw ('margin')
 dev_set_color ('red')
 dev_set_line_width (3)
 
 // 定义数组
 Message := '这个实例演示如何创建一个模板'
 Message[1] := '形状匹配模板建立与保存'
 Message[2] := '模板匹配的使用'
 // 显示数组话语
 disp_message (WindowHandle, Message, 'window', 12, 12, 'black', 'true')
 // 继续提示语显示
 disp_continue_message (WindowHandle, 'black', 'true')
 // 执行断点处
 stop()
 
 // 预处理获得优质的模板图像
 threshold (Image, Regions, 0, 122)
 dev_set_colored(12)
 connection (Regions, ConnectedRegions)
 fill_up (ConnectedRegions, RegionFillUp)
 select_shape (RegionFillUp, SelectedRegions, 'area', 'and', 14845, 57911.9)
 dilation_circle (SelectedRegions, RegionDilation, 3.5)
 reduce_domain (Image, RegionDilation, ImageReduced)
 
 // 生成模板
 determine_shape_model_params(ImageReduced, 'auto', -0.39, 0.79, 0.9, 1.1, 'auto', 'use_polarity', 'auto', 'auto', 'all', ParameterName, ParameterValue)
 // 监视模板
 inspect_shape_model (ImageReduced, ModelImages, ModelRegions, 5, 40)
 
 // 创建形状模板
 // 使用用图像创建带有缩放的匹配模板
 create_scaled_shape_model (ImageReduced, 5, rad(-45), rad(90), 0, 0.8, 1.0, 0, ['none','no_pregeneration'], 'ignore_global_polarity', 40, 10, ModelID)
 // 保存模板
 write_shape_model (ModelID, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/shapemodel_huanbao.shm')
 // 清除模板
 clear_shape_model (ModelID)
  
 // 模板匹配
 // 获取检测目标图像
 read_image (Image1, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/三个环保标志.png')
 // 提示语定义与显示
 Message := '形状匹配步骤开始'
 disp_message (WindowHandle, Message, 'window', 12, 12, 'black', 'true')
 // 读取形状模板
 read_shape_model ('E:/Halcon/算法/11模板匹配/基于形状的模板匹配/shapemodel_huanbao.shm', ModelID1)
 // 模板匹配，后面的几个参数是匹配图像的位置状态等参数
 find_scaled_shape_model (Image1, ModelID1, rad(-45), rad(90), 0.8, 1.0, 0.5, 0, 0.5, 'least_squares', 5, 0.8, Row, Column, Angle, Scale, Score)
 // 返回一个轮廓模型的轮廓表示
 get_shape_model_contours (ModelContours, ModelID1, 1)
 
 dev_display (Image1)
 // 循环
 for i:=0 to |Score|-1 by 1
     // 得到对应匹配目标的旋转矩阵
     vector_angle_to_rigid (0, 0, 0, Row[i], Column[i], Angle[i], HomMat2DRotate)
     // 在旋转矩阵的基础上添加缩放量，生成新的矩阵
     hom_mat2d_scale (HomMat2DRotate, Scale[i], Scale[i], Row[i],Column[i], HomMat2DScale)
     // 矩阵变换（xld基础上）
     affine_trans_contour_xld (ModelContours, ContoursAffineTrans, HomMat2DScale)
     // xld转换成region
     gen_region_contour_xld (ContoursAffineTrans, Region, 'filled')
     // 对区域，生成最小外接矩形
     smallest_rectangle1 (Region, Row1, Column1, Row2, Column2)
     // 使用绿色矩形框，框选匹配结果
     dev_set_color ('green')
     disp_rectangle1 (WindowHandle, Row1[0], Column1[0], Row2[0], Column2[0])
     // 使用红色勾画匹配结果轮廓
     dev_set_color ('red')
     dev_display (ContoursAffineTrans)
     // 显示各匹配结果提示语
     disp_message (WindowHandle, '第'+(i+1)+'个', 'window', Row1[0]-30, (Column1[0]+Column2[0])/2-10, 'green', 'false')
 endfor
 
 // 提示语定义与显示
 Message := '形状匹配结果如下：'
 disp_message (WindowHandle, Message, 'window', 12, 12, 'green', 'false')
 // 将窗口内容写入图像对象
 dump_window_image (Image2, WindowHandle)
 write_image (Image2, 'png', 0, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/环保标志结果.bmp.png')

(3) Lumière du matin

 dev_update_off()
 dev_close_window()
 // 读取图像
 read_image(Image, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/晨光模板图像.jpg')
 get_image_size(Image, Width, Height)
 rgb1_to_gray(Image, GrayImage)
 dev_open_window_fit_image(GrayImage, 0, 0, -1, -1, WindowHandle)
 dev_display(GrayImage)
 
 // 预处理
 binary_threshold(GrayImage, Region, 'max_separability', 'dark', UsedThreshold)
 connection(Region, ConnectedRegions)
 fill_up(ConnectedRegions, RegionFillUp)
 select_shape(RegionFillUp, SelectedRegions, 'area', 'and', 22500, 23000)
 dilation_circle(SelectedRegions, RegionDilation, 3.5)
 reduce_domain(GrayImage, RegionDilation, ImageReduced)
 
 // 获取金字塔层数，图像监视
 determine_shape_model_params(ImageReduced, 'auto', -0.39, 0.79, 0.9, 1.1, 'auto', 'use_polarity', 'auto', 'auto', 'all', ParameterName, ParameterValue)
 inspect_shape_model(ImageReduced, ModelImages, ModelRegions, 5, 20)
 
 dev_set_draw ('margin')
 dev_set_line_width(3)
 
 // 创建模板
 create_shape_model(ImageReduced, 'auto', rad(0), rad(1), 'auto', 'auto', 'use_polarity', 20, 3, ModelID)
 write_shape_model(ModelID, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/shapemodel_chenguang.shm')
 clear_shape_model(ModelID)
 
 // 在目标图像中寻找模板图像
 read_image(ImageTest, 'E:/Halcon/算法/11模板匹配/基于形状的模板匹配/晨光测试图像.jpg')
 message:= '查找模板'
 disp_message(WindowHandle, message, 'window', 16, 16, 'black', 'true')
 read_shape_model('E:/Halcon/算法/11模板匹配/基于形状的模板匹配/shapemodel_chenguang.shm',ModelID1)
 find_shape_model(ImageTest, ModelID1, rad(0), rad(1), 0.5, 0, 0, 'least_squares', 5, 0.8, Row, Column, Angle, Score)
 get_shape_model_contours(ModelContours, ModelID1, 1)
 dev_display(ImageTest)
 // 显示匹配结果，将匹配得到的实例以形状轮廓的形式绘制出来
 dev_display_shape_matching_results(ModelID1, 'red', Row, Column, Angle, 1, 1, 0)
 // 匹配结束，释放模板资源
 clear_shape_model (ModelID1)