Halcon 颜色检测

算子

decompose3 - 将三通道图像转换为三个图R,G,B图像

decompose3(MultiChannelImage : Image1, Image2, Image3 : : )
MultiChannelImage：输入三色图像
Image1：输出Red 图像
Image2：输出Green图像
Image3：输出Blue图像

trans_from_rgb 将图像转换为HSV 图像

trans_from_rgb(ImageRed, ImageGreen, ImageBlue : ImageResult1, ImageResult2, ImageResult3 : ColorSpace : ) 
ImageRed, ImageGreen, ImageBlue   输入图像红色通道，输入图像绿色通道，输入图像蓝色通道
ImageResult1, ImageResult2, ImageResult3   输出图像通道1，通道2，通道3
ColorSpace    颜色空间

create_color_trans_lut — 创建RGB颜色空间到任意颜色空间的图像转换查找表
参数

create_color_trans_lut( : : ColorSpace, TransDirection, NumBits : ColorTransLUTHandle)
ColorSpace（输入控制） string → (字符串)
输出图像的颜色空间。
默认值：'hsv'
值列表：'argyb'、'cielab'、'cielchab'、'cielchuv'、'cieluv'、'ciexyz'、'ciexyz3'、'ciexyz4'、'ciexyz4'、'hls'、'hls'、'hsi'、'hsv'、'i1i2i3'、'ihs'、'lms'、'yiq'、'yuv'
TransDirection（输入控制） string → (字符串)
颜色空间转换的方向。
默认值：'from_rgb'
值列表：'from_rgb'、'to_rgb'
NumBits（输入控制） integer → (整数)
输入图像的位数。
默认值：8
值列表：8
ColorTransLUTHandle（输出控制） color_trans_lut → (整数)
颜色空间转换查找表的句柄。

apply_color_trans_lut — 使用预生成的查找表进行颜色空间转换。

apply_color_trans_lut(Image1, Image2, Image3 : ImageResult1, ImageResult2, ImageResult3 : ColorTransLUTHandle : )
参数
Image1（输入对象） singlechannelimage(-array) → 对象（字节）
输入图像（通道2）。
Image2（输入对象） singlechannelimage(-array) → 对象（字节）
输入图像（通道2）。
Image3（输入对象） singlechannelimage(-array) → 对象（字节）
输入图像（通道3）。
ImageResult1（输出对象） singlechannelimage(-array) → 对象（字节）
颜色转换后的输出图像（通道1）。
ImageResult2（输出对象） singlechannelimage(-array) → 对象（字节）
颜色转换后的输出图像（通道2）。
ImageResult3（输出对象） singlechannelimage(-array) → 对象（字节）
颜色转换后的输出图像（通道3）。
ColorTransLUTHandle（输入控制） color_trans_lut → (整数)
颜色空间转换查找表的句柄。

copy_obj 图像图层复制

copy_obj(Objects : ObjectsSelected : Index, NumObj : )
这些参数用于控制 copy_obj 函数的操作，具体如下：

    Objects（输入对象）：待复制的对象或对象数组。
    ObjectsSelected（输出对象）：复制后的对象或对象数组。
    Index（输入控制）：要复制的对象的起始索引。
        默认值为 1，建议的取值范围包括 1、2、3 等。
        典型取值范围为大于等于1的整数。
    NumObj（输入控制）：要复制的对象数量，或者设为 -1 表示复制所有对象。
        默认值为 1，建议的取值范围包括 -1、1、2、3 等。
        典型取值范围为不小于 -1 的整数，当设为 -1 时表示复制从索引 Index 开始的所有对象。

人工智能算子

create_class_mlp 创建用于分类或回归的多层感知器。

create_class_mlp( : : NumInput, NumHidden, NumOutput, OutputFunction, Preprocessing, NumComponents, RandSeed : MLPHandle)
参数解释如下：

    NumInput（输入控制）：MLP的输入变量（特征）数量。
    NumHidden（输入控制）：MLP的隐藏单元数量。
    NumOutput（输入控制）：MLP的输出变量（类别）数量。
    OutputFunction（输入控制）：MLP输出层激活函数的类型。
    Preprocessing（输入控制）：用于转换特征向量的预处理类型。
    NumComponents（输入控制）：预处理参数，转换特征的数量（对于某些预处理类型）。
    RandSeed（输入控制）：用于初始化MLP随机值的随机数生成器种子值。
    MLPHandle（输出控制）：MLP句柄，用于引用创建的多层感知器。

add_samples_image_class_mlp 将图像中的训练样本添加到多层感知器的训练数据中。

add_samples_image_class_mlp(Image, ClassRegions : : MLPHandle : )
参数解释如下：
    Image（输入对象）：训练图像，可以是多通道图像。
    ClassRegions（输入对象）：要进行训练的类别区域。
    MLPHandle（输入控制，状态被修改）：MLP句柄，用于指定要使用的多层感知器模型。

train_class_mlp 训练多层感知器

train_class_mlp( : : MLPHandle, MaxIterations, WeightTolerance, ErrorTolerance : Error, ErrorLog)
这些参数用于控制多层感知器（MLP）模型的训练过程，具体如下：
    MLPHandle（输入控制，状态被修改）：MLP句柄，指定要使用的多层感知器模型。
    MaxIterations（输入控制）：优化算法的最大迭代次数。
    WeightTolerance（输入控制）：权重变化阈值，用于控制优化算法在两次迭代之间权重的差异。
    ErrorTolerance（输入控制）：误差变化阈值，用于控制优化算法在两次迭代之间训练数据上的平均误差的差异。
    Error（输出控制）：MLP在训练数据上的平均误差。
    ErrorLog（输出控制）：MLP在训练数据上的平均误差随着优化算法迭代次数的变化情况。

classify_image_class_mlp 使用多层感知器对图像进行分类。

classify_image_class_mlp(Image : ClassRegions : MLPHandle, RejectionThreshold : )
这些参数用于进行图像分类和分割，具体如下：

    Image（输入对象）：输入图像，可以是多通道图像。
    ClassRegions（输出对象）：分类后的类别区域。
    MLPHandle（输入控制）：MLP句柄，指定要使用的多层感知器模型。
    RejectionThreshold（输入控制）：分类拒绝阈值，用于确定是否拒绝对某个像素进行分类。
        默认值为0.5，建议的取值范围为0.0到1.0之间。
        若RejectionThreshold设置为0.5，则类别概率小于0.5的像素将被拒绝分类。

clear_class_mlp 分类器清楚

clear_class_mlp( : : MLPHandle : )
MLPHandle 句柄

高斯混合模型算子

create_class_gmm 创建高斯混合分类器

create_class_gmm( : : NumDim, NumClasses, NumCenters, CovarType, Preprocessing, NumComponents, RandSeed : GMMHandle)
这些参数是用于控制 GMM（高斯混合模型）的创建与初始化的，具体如下：
    NumDim（输入控制）：特征空间的维数。
        默认值为 3，建议的取值范围包括 1、2、3、4 等。
        取值范围为不小于 1 的整数。
    NumClasses（输入控制）：GMM 的类别数量。
        默认值为 5，建议的取值范围包括 1、2、3、4 等。
        取值范围为不小于 1 的整数。
    NumCenters（输入控制）：每个类别的中心数量。
        默认值为 1，建议的取值范围包括 1、2、3、4 等。
        取值范围为不小于 1 的整数。
    CovarType（输入控制）：协方差矩阵的类型。
        默认值为 'spherical'，可选择 'diag'、'full' 或 'spherical'。
    Preprocessing（输入控制）：用于转换特征向量的预处理类型。
        默认值为 'normalization'，可选择 'canonical_variates'、'none'、'normalization' 或 'principal_components'。
    NumComponents（输入控制）：预处理参数，转换后的特征数量（仅在 Preprocessing = 'canonical_variates' 或 'normalization' 时有效）。
        默认值为 10，建议的取值范围包括 1、2、3、4 等。
        取值范围为不小于 1 的整数。
    RandSeed（输入控制）：用于初始化 GMM 随机值的随机数生成器的种子值。
        默认值为 42。
    GMMHandle（输出控制）：GMM 的句柄。

add_samples_image_class_gmm 添加样本

add_samples_image_class_gmm(Image, ClassRegions : : GMMHandle, Randomize : )
这些参数用于训练 GMM 模型的过程，具体如下：

    Image（输入对象）：训练图像，可以是多通道图像。
    ClassRegions（输入对象）：待训练类别的区域。这里采用区域数组来表示不同类别的区域。
    GMMHandle（输入控制，状态被修改）：GMM 模型的句柄，用于指定训练的模型。
    Randomize（输入控制）：添加到训练数据中的高斯噪声的标准差。
        默认值为 0.0。
        建议的取值范围为 0.0、1.5、2.0 等。
        Randomize 的取值应不小于 0.0。

train_class_gmm 训练

train_class_gmm( : : GMMHandle, MaxIter, Threshold, ClassPriors, Regularize : Centers, Iter)
这些参数用于控制 GMM 的训练和迭代过程，具体如下：

    GMMHandle（输入控制，状态被修改）：GMM 模型的句柄，用于指定训练的模型。
    MaxIter（输入控制）：期望最大化算法的最大迭代次数。
        默认值为 100。
        建议的取值范围包括 10、20、30、50、100、200 等。
    Threshold（输入控制）：确定期望最大化算法终止的误差相对变化阈值。
        默认值为 0.001。
        建议的取值范围包括 0.001、0.0001 等。
        Threshold 的取值范围为大于等于 0.0 且小于等于 1.0。
    ClassPriors（输入控制）：确定类别的先验概率的模式。
        默认值为 'training'，表示使用训练数据中的类别先验概率。
        可选值为 'training' 和 'uniform'。
    Regularize（输入控制）：防止协方差矩阵奇异性的正则化值。
        默认值为 0.0001。
        Regularize 的取值范围为大于等于 0.0 且小于 1.0。
    Centers（输出控制）：每个类别找到的中心数量。
    Iter（输出控制）：每个类别执行的迭代次数。

clear_class_gmm 清除句柄

clear_class_gmm( : : GMMHandle : )

create_class_lut_gmm 使用高斯混合模型创建查找表，对字节图像进行分类。

create_class_lut_gmm( : : GMMHandle, GenParamName, GenParamValue : ClassLUTHandle)
这些参数用于控制 LUT（查找表）分类器的创建过程，具体如下：
    GMMHandle（输入控制）：GMM 模型的句柄，用于指定要创建 LUT 分类器的模型。
    GenParamName（输入控制）：可以调整用于创建 LUT 分类器的通用参数的名称数组。
        默认值为 []，表示没有通用参数需要调整。
        建议的取值范围包括 'bit_depth'、'class_selection'、'rejection_threshold' 等。
    GenParamValue（输入控制）：可以调整用于创建 LUT 分类器的通用参数的值数组。
        默认值为 []，表示没有通用参数需要调整。
        建议的取值范围包括整数、实数或字符串，如 8、7、6、'fast'、'best' 等。
    ClassLUTHandle（输出控制）：LUT 分类器的句柄，用于指定创建的 LUT 分类器。

classify_image_class_lut 颜色分类表

classify_image_class_lut(Image : ClassRegions : ClassLUTHandle : )
这些参数用于执行基于 LUT（查找表）分类器的图像分类操作，具体如下：

    Image（输入对象）：输入的多通道图像，通常为字节类型。这是需要进行分类的图像数据。
    ClassRegions（输出对象）：分割后的类别区域数组对象，用于存储分类结果。每个类别将对应一个区域。
    ClassLUTHandle（输入控制）：LUT 分类器的句柄，用于指定要应用的 LUT 分类器。

clear_class_lut 清除句柄

clear_class_lut( : : ClassLUTHandle : )
ClassLUTHandle  句柄

Halcon 示例1 通过色调和饱和度识别颜色

* color_simple.hdev: segment yellow cable in HSV color space
dev_close_window ()
dev_open_window (0, 0, 640, 480, 'black', WindowHandle)
for i := 1 to 2 by 1
    read_image (Image, 'cable' + i)
    * 获取rgb图像
    decompose3 (Image, Red, Green, Blue)
    * 将rgb 图像转换为 HSI图像
    trans_from_rgb (Red, Green, Blue, Hue, Saturation, Intensity, 'hsv')
    threshold (Saturation, HighSaturation, 100, 255)
    reduce_domain (Hue, HighSaturation, HueHighSaturation)
    threshold (HueHighSaturation, Yellow, 20, 50)
    connection (Yellow, ConnectedRegions)
    select_shape_std (ConnectedRegions, SelectedRegions, 'max_area', 0)
    closing_circle (SelectedRegions, Yellow, 3.5)
    reduce_domain (Image, Yellow, ImageReduced)
    dev_display (HueHighSaturation)
    dev_display (ImageReduced)
    stop ()
endfor

Halcon 示例2通过饱和度和色调进行颜色检测

* color_fuses.hdev: classify fuses by color
dev_update_window ('off')
* ****
* step: set up fuse properties and hue ranges
* ****
FuseColors := ['Orange','Red','Blue','Yellow','Green']
FuseTypes := [5,10,15,20,30]
* HueRanges: Orange 10-30, Red 0-10...
HueRanges := [10,30,0,10,125,162,30,64,96,128]
Count := 0
dev_close_window ()
dev_open_window (0, 0, 800, 600, 'black', WH)
while (Count <= 4)
    * ****
    * step: acquire image
    * ****
    read_image (Image, 'color/color_fuses_0' + Count)
    dev_display (Image)
    set_tposition (WH, 12, 512)
    write_string (WH, 'color/color_fuses0' + Count + '.png')
    * ****
    * step: extract saturated hues
    * ****
    * 1.提取饱和度和色调
    decompose3 (Image, Red, Green, Blue)
    trans_from_rgb (Red, Green, Blue, Hue, Saturation, Intensity, 'hsv')
    threshold (Saturation, Saturated, 60, 255)
    reduce_domain (Hue, Saturated, HueSaturated)
    for Fuse := 0 to |FuseTypes| - 1 by 1
        * ****
        * step: classify specific fuse
        * ****
        * 颜色分类
        threshold (HueSaturated, CurrentFuse, HueRanges[Fuse * 2], HueRanges[Fuse * 2 + 1])
        connection (CurrentFuse, CurrentFuseConn)
        fill_up (CurrentFuseConn, CurrentFuseFill)
        select_shape (CurrentFuseFill, CurrentFuseSel, 'area', 'and', 6000, 20000)
        area_center (CurrentFuseSel, FuseArea, Row1, Column1)
        dev_set_color ('magenta')
        for i := 0 to |FuseArea| - 1 by 1
            set_tposition (WH, Row1[i], Column1[i])
            write_string (WH, FuseColors[Fuse] + ' ' + FuseTypes[Fuse] + ' Ampere')
        endfor
        set_tposition (WH, 24 * (Fuse + 1), 12)
        dev_set_color ('slate blue')
        write_string (WH, FuseColors[Fuse] + ' Fuses: ' + |FuseArea|)
    endfor
    stop ()
    Count := Count + 1
endwhile
dev_update_window ('on')

Halcon 使用颜色分类表进行颜色分类

* color_fuses_lut_trans.hdev: classify fuses by color
dev_update_off ()
* ****
* step: set up fuse properties and hue ranges
* ****
FuseColors := ['Orange','Red','Blue','Yellow','Green']
DisplayColors := ['coral','red','blue','goldenrod','forest green']
FuseTypes := [5,10,15,20,30]
* HueRanges: Orange 10-30, Red 0-10...
HueRanges := [10,30,0,10,125,162,30,64,96,128]
dev_close_window ()
read_image (Image, 'color/color_fuses_00')
dev_open_window_fit_image (Image, 0, 0, -1, -1, WindowHandle)
set_display_font (WindowHandle, 14, 'mono', 'true', 'false')
* ****
* step: create look-up-table for color space transformation
* ****
*  *1.创建颜色查找表
create_color_trans_lut ('hsv', 'from_rgb', 8, ColorTransLUTHandle)
for Count := 0 to 4 by 1
    * ****
    * step: acquire image
    * ****
    read_image (Image, 'color/color_fuses_0' + Count)
    dev_display (Image)
    disp_message (WindowHandle, 'color/color_fuses0' + Count + '.png', 'window', 12, 512, 'black', 'true')
    * ****
    * step: extract saturated hues
    * ****
    *将图片转换为R，G，B三张图片
    decompose3 (Image, Red, Green, Blue)
    * 2.使用预生成的查找表进行颜色空间转换
    apply_color_trans_lut (Red, Green, Blue, Hue, Saturation, Intensity, ColorTransLUTHandle)
    * 阈值处理
    threshold (Saturation, Saturated, 60, 255)
    * 图片裁剪
    reduce_domain (Hue, Saturated, HueSaturated)
    Output := []
    for Fuse := 0 to |FuseTypes| - 1 by 1
        * ****
        * step: classify specific fuse
        * ****
        * 进行分类
        threshold (HueSaturated, CurrentFuse, HueRanges[Fuse * 2], HueRanges[Fuse * 2 + 1])
        * 形成单独的连通域
        connection (CurrentFuse, CurrentFuseConn)
        *填充
        fill_up (CurrentFuseConn, CurrentFuseFill)
        *筛选面积
        select_shape (CurrentFuseFill, CurrentFuseSel, 'area', 'and', 6000, 20000)
        * 获取中心点的面积和行列坐标
        area_center (CurrentFuseSel, FuseArea, Row1, Column1)
        * 设置显示颜色为品红色
        dev_set_color ('magenta')
        disp_message (WindowHandle, FuseColors[Fuse] + ' ' + FuseTypes[Fuse] + ' Ampere', 'image', Row1 + 40, Column1 - 100, DisplayColors[Fuse], 'white')
        Output := [Output,FuseColors[Fuse] + ' Fuses: ' + |FuseArea|]
    endfor
    disp_message (WindowHandle, Output, 'window', 12, 12, DisplayColors, 'true')
    disp_continue_message (WindowHandle, 'black', 'true')
    stop ()
endfor
dev_update_on ()
dev_close_window ()
clear_color_trans_lut (ColorTransLUTHandle)

Halcon 训练的方法识别颜色

* This example demonstrates a completeness check of colored game
* pieces using MLP classification. The training and application
* of the classifier is first shown on colored images and then on
* gray images.
* 
dev_update_off ()
dev_close_window ()
dev_open_window (0, 0, 557, 416, 'black', WindowHandle)
set_display_font (WindowHandle, 14, 'mono', 'true', 'false')
dev_set_draw ('margin')
* 
* Initialization
ImageRootName := 'color/color_pieces_0'
Regions := ['yellow','pink','blue','background']
Highlight := ['goldenrod','magenta','cyan']
gen_empty_obj (Classes)
* 
* Train and apply the MLP classifier
for Mode := 0 to 1 by 1
    dev_set_color ('black')
    read_image (Image, ImageRootName + '0')
    * 
    * Simulate gray image
    * 灰度图像进行识别
    if (Mode == 1)
        rgb1_to_gray (Image, GrayImage)
        compose3 (GrayImage, GrayImage, GrayImage, Image)
        dev_display (Image)
        disp_message (WindowHandle, 'Train and apply the classes again on gray images', 'window', 12, 12, 'black', 'false')
        disp_continue_message (WindowHandle, 'black', 'true')
        stop ()
    endif
    * 
    * Colored images
    if (Mode == 0)
        * 
        * Specify color classes
        * 没有模型
        for I := 1 to 4 by 1
            dev_display (Image)
            dev_display (Classes)
            disp_message (WindowHandle, ['Drag rectangle inside ' + Regions[I - 1] + ' color','Click right mouse button to confirm'], 'window', 24, 12, 'black', 'false')
            * 绘制矩形
            draw_rectangle1 (WindowHandle, Row1, Column1, Row2, Column2)
            gen_rectangle1 (Rectangle, Row1, Column1, Row2, Column2)
            * 将图像进行合并，仅存储对应图像和区域的引用，而不分配新的内存
            concat_obj (Classes, Rectangle, Classes)
        endfor
    endif
    * 
    * Train the specified color classes
    * 
    * 创建分类器
    create_class_mlp (3, 7, 4, 'softmax', 'normalization', 3, 42, MLPHandle)
    * 添加训练样本
    add_samples_image_class_mlp (Image, Classes, MLPHandle)
    disp_message (WindowHandle, 'Training...', 'window', 100, 12, 'black', 'false')
    *训练
    train_class_mlp (MLPHandle, 400, 0.5, 0.01, Error, ErrorLog)
    * 
    * Use the trained MLP classifier to test if each image
    * contains four game pieces of each color
    for J := 0 to 3 by 1
        read_image (Image, ImageRootName + J)
        if (Mode == 1)
            rgb1_to_gray (Image, GrayImage)
            compose3 (GrayImage, GrayImage, GrayImage, Image)
        endif
        * 
        * Apply the trained classes
        * 分类
        classify_image_class_mlp (Image, ClassRegions, MLPHandle, 0.5)
        dev_display (Image)
        disp_message (WindowHandle, 'Looking for 4 game pieces of each color ...', 'window', 24, 12, 'black', 'false')
        dev_set_line_width (2)
        * 
        * Count the number of game pieces for each color class
        for Figure := 1 to 3 by 1
            * 复制图层
            copy_obj (ClassRegions, ObjectsSelected, Figure, 1)
            * 联合成单个连通域
            connection (ObjectsSelected, ConnectedRegions)
            select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 400, 99999)
            * 计算连通域的数量
            count_obj (SelectedRegions, Number)
            dev_set_color (Highlight[Figure - 1])
            dev_display (SelectedRegions)
            OutString := Regions[Figure - 1] + ': ' + Number + '   '
            dev_set_color ('green')
            disp_message (WindowHandle, OutString, 'window', 24 + 30 * Figure, 12, 'black', 'false')
            if (Number != 4)
                disp_message (WindowHandle, 'Not OK', 'window', 24 + 30 * Figure, 120, 'red', 'false')
            else
                disp_message (WindowHandle, 'OK', 'window', 24 + 30 * Figure, 120, 'green', 'false')
            endif
        endfor
        if (J < 3 or Mode == 0)
            disp_continue_message (WindowHandle, 'black', 'true')
            stop ()
        endif
    endfor
    clear_class_mlp (MLPHandle)
endfor
dev_clear_window ()
dev_display (Image)
Message := 'The game pieces cannot be classified reliable on'
Message[1] := 'gray images because the gray values of the'
Message[2] := 'game pieces cannot always be distinguished from'
Message[3] := 'the gray values of the background.'
disp_message (WindowHandle, Message, 'window', 12, 12, 'black', 'true')

Halcon 使用高斯分类器

* In this example five different color fuses are segmented with
* a look-up table classifier (LUT) based on a Gaussian Mixture
* Model (GMM).
* 
dev_update_off ()
dev_close_window ()
dev_open_window (0, 0, 800, 600, 'white', WindowHandle)
dev_set_draw ('margin')
ImageRootName := 'color/color_fuses_0'
FuseTypes := [5,10,15,20,30]
FuseColors := ['Orange','Red','Blue','Yellow','Green']
FuseHighlight := ['orange','red','blue','goldenrod','forest green']
DisplayTextShift := [85,65,75,85,85]
dev_set_color ('white')
dev_set_line_width (2)
read_image (Image, ImageRootName + '0')
dev_display (Image)
* 
* Define ROIs for the training data of the classifier
set_display_font (WindowHandle, 14, 'mono', 'true', 'false')
gen_rectangle1 (FuseOrange, 195, 90, 230, 120)
dev_display (FuseOrange)
disp_message (WindowHandle, 'Orange Fuse', 'image', 160, 90 - 65, 'black', 'true')
gen_rectangle1 (FuseRed, 191, 280, 226, 310)
dev_display (FuseRed)
disp_message (WindowHandle, 'Red Fuse', 'image', 160, 280 - 55, 'black', 'true')
gen_rectangle1 (FuseBlue, 190, 470, 225, 500)
dev_display (FuseBlue)
disp_message (WindowHandle, 'Blue Fuse', 'image', 160, 470 - 60, 'black', 'true')
gen_rectangle1 (FuseYellow, 192, 672, 227, 702)
dev_display (FuseYellow)
disp_message (WindowHandle, 'Yellow Fuse', 'image', 160, 672 - 70, 'black', 'true')
gen_rectangle1 (FuseGreen, 197, 880, 232, 910)
dev_display (FuseGreen)
disp_message (WindowHandle, 'Green Fuse', 'image', 160, 880 - 65, 'black', 'true')
gen_empty_obj (Classes)
concat_obj (FuseOrange, FuseRed, Classes)
concat_obj (Classes, FuseBlue, Classes)
concat_obj (Classes, FuseYellow, Classes)
concat_obj (Classes, FuseGreen, Classes)
disp_message (WindowHandle, 'ROIs for the training data', 'window', 12, 12, 'black', 'true')
disp_continue_message (WindowHandle, 'black', 'true')
stop ()
* 
* Create the GMM classifier, add the samples, and train it
* 创建分类器
create_class_gmm (3, 5, 1, 'full', 'none', 3, 42, GMMHandle)
* 添加模板
add_samples_image_class_gmm (Image, Classes, GMMHandle, 0)
disp_message (WindowHandle, 'Training GMM classifier...', 'window', 48, 12, 'black', 'true')
*训练分类器
train_class_gmm (GMMHandle, 100, 0.001, 'training', 0.001, Centers, Iter)
* 
* Create the GMM-based LUT classifier
disp_message (WindowHandle, 'Creating LUT classifier...', 'window', 84, 12, 'black', 'true')
* 创建颜色识别表
create_class_lut_gmm (GMMHandle, ['bit_depth','rejection_threshold'], [6,0.03], ClassLUTHandle)
clear_class_gmm (GMMHandle)
* 
* Segment images with LUT classifier
for Img := 0 to 3 by 1
    read_image (Image, ImageRootName + Img)
    count_seconds (T1)
    *颜色分类
    classify_image_class_lut (Image, ClassRegions, ClassLUTHandle)
    count_seconds (T2)
    TimeToClassify := (T2 - T1) * 1000
    dev_display (Image)
    dev_set_line_width (3)
    for Fuse := 1 to 5 by 1
        * 
        * Perform post-processing on returned classes
        copy_obj (ClassRegions, ObjectsSelected, Fuse, 1)
        closing_circle (ObjectsSelected, RegionClosing, 3.5)
        connection (RegionClosing, ConnectedRegions)
        select_shape (ConnectedRegions, SelectedRegions, 'area', 'and', 2500, 99999)
        fill_up (SelectedRegions, RegionFillUp)
        area_center (RegionFillUp, Area, Row, Column)
        shape_trans (RegionFillUp, RegionTrans, 'convex')
        dev_set_color (FuseHighlight[Fuse - 1])
        dev_display (RegionTrans)
        * 
        disp_message (WindowHandle, FuseColors[Fuse - 1] + ' ' + FuseTypes[Fuse - 1] + ' A', 'image', Row - 10, Column - DisplayTextShift[Fuse - 1], FuseHighlight[Fuse - 1], 'white')
    endfor
    disp_message (WindowHandle, TimeToClassify$'.1f' + ' ms', 'window', 12, 12, 'black', 'true')
    if (Img < 3)
        disp_continue_message (WindowHandle, 'black', 'true')
        stop ()
    endif
endfor
* 
clear_class_lut (ClassLUTHandle)
disp_message (WindowHandle, 'No more lines to execute', 'window', 50, 12, 'black', 'true')

逼近法交集求颜色

read_image (Image, 'cable1')
get_image_size(Image, Width, Height)

dev_open_window_fit_image(Image, 0, 0, -1, -1, WindowHandle)
dev_display(Image)

draw_rectangle1(WindowHandle, Row1, Column1, Row2, Column2)
gen_rectangle1(Rectangle, Row1, Column1, Row2, Column2)
reduce_domain(Image, Rectangle, ImageReduced)

*将其转换为RGB
decompose3(ImageReduced, ImageR, ImageG, ImageB)

*获取R黑色区域
threshold (ImageR, Regions1, 0, 47)
*获取G黑色区域
threshold (ImageG, Regions2, 40, 55)
*获取B黑色区域
threshold (ImageB, Regions3, 2, 53)

* 获取RG 黑色区域的交集
intersection(Regions1, Regions2, RegionIntersection)
*获取RGB的交集
intersection(RegionIntersection, Regions3, RegionIntersection1)
connection(RegionIntersection1, ConnectedRegions)
area_center(ConnectedRegions, Area, Row, Column)
*获取区域的最大值
tuple_max(Area, Max)
select_shape(ConnectedRegions, SelectedRegions, 'area', 'and', Max, Max)
area_center(SelectedRegions, Area1, Row3, Column3)
dev_display(SelectedRegions)
disp_message(WindowHandle, '黑色', 'window', Row3, Column3, 'black', 'false')

mlp分类

read_image (Image, 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_05.png')
get_image_size(Image, Width, Height)
dev_open_window_fit_size(0, 0, Width, Height, -1, -1, WindowHandle)
dev_display(Image)

*1.创建分类器 第1个变量颜色通道 第3个变量颜色个数
create_class_mlp(3, 10, 5, 'softmax', 'normalization', 10, 42, MLPHandle)

*准备样品区域 包含背景
gen_empty_obj(EmptyObject)

for Index := 1 to 5 by 1
    *缩放 让样本更明显
    scale_image (Image, ImageScaled, 2.00787, -2)
    draw_rectangle1(WindowHandle, Row1, Column1, Row2, Column2)
    gen_rectangle1(Rectangle, Row1, Column1, Row2, Column2)
    concat_obj(EmptyObject, Rectangle,EmptyObject)
    
endfor
stop()
*添加样本图像
add_samples_image_class_mlp(ImageScaled,EmptyObject, MLPHandle)
*add_samples_image_class_mlp(Image, EmptyObject, MLPHandle)

* 训练
train_class_mlp(MLPHandle, 200, 1, 0.01, Error, ErrorLog)

*识别
MLP_COLOR:=2  //选择要筛选的颜色

* Image Acquisition 01: Code generated by Image Acquisition 01
ImageFiles := []
ImageFiles[0] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_back_model.png'
ImageFiles[1] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_front_model.png'
ImageFiles[2] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_01.png'
ImageFiles[3] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_02.png'
ImageFiles[4] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_03.png'
ImageFiles[5] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_04.png'
ImageFiles[6] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_05.png'
ImageFiles[7] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_06.png'
ImageFiles[8] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_07.png'
ImageFiles[9] := 'C:/Users/Public/Documents/MVTec/HALCON-17.12-Progress/examples/images/color/clamp_pile_08.png'
for Index := 0 to |ImageFiles| - 1 by 1
    read_image (Image, ImageFiles[Index])
    *识别图片
    classify_image_class_mlp(Image, ClassRegions, MLPHandle, 0.5)
    * 选择第二个
    select_obj(ClassRegions, ObjectSelected, MLP_COLOR)
    
    area_center(ObjectSelected, Area, Row, Column)
    if(Area>=1000) //筛选到了想要的颜色
        dev_display(Image)
        dev_display(ObjectSelected)
        dev_set_color('red')
        dev_set_draw('margin')
        dev_set_line_width(4)
        set_display_font(WindowHandle, 16, 'mono', 'true', 'false')
        disp_message(WindowHandle, 'OK'+MLP_COLOR, 'window', Row, Column, 'black', 'true')
    else
        set_display_font(WindowHandle, 16, 'mono', 'true', 'false')
        disp_message(WindowHandle, 'NG', 'window', Row, Column, 'black', 'true')
    endif
    
endfor