Halcon图像的指针获取与图像生成

最新推荐文章于 2025-03-14 08:56:28 发布
最新推荐文章于 2025-03-14 08:56:28 发布
阅读量4.4k 收藏 12
点赞数 3
分类专栏： C++图像处理 halcon 文章标签： c++ c# 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_58369313/article/details/131260714
版权
本文介绍了如何在C++和C#中使用Halcon库获取图像的指针，特别是针对单通道和多通道图像的处理。通过算子GetImagePointer1和自定义函数rgb3_to_interleaved，将三通道彩色图像转换为单通道图像，以便进行进一步的图像操作。代码示例详细展示了读取图像、转换图像以及生成新图像的过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、获取halcon图像的指针（C++）

1、若图像为单通道图像，使用算子 GetImagePointer1() 获取单通道图像指针。
2、若图像为多通道图像，使用自定义函数 rgb3_to_interleaved() 将三通道彩色图像转换为具有交错颜色信息的单通道图像(width*3),然后再使用算子 GetImagePointer1()获取单通道图像指针。
3、根据以上2个步骤获取的图像指针和宽高信息，
使用算子GetImagePointer1() 生成单通道图像，
使用算子GenImageInterleaved() 生成多通道图像(width/3)，该算子在halcon中有例程，并且其中有该函数 rgb3_to_interleaved() 的实现。
4、以上的3个步骤对应以下代码的3个步骤：

//1. 读取图像，获取图像指针
HObject src, srcGray;
ReadImage(&src, "./pic/3.png");

HTuple  hv_Pointer, hv_Type, hv_Width, hv_Height, hv_Channels;
CountChannels(src, &hv_Channels);//获取通道数
if (hv_Channels.I() != 1)
{
	// 将三通道彩色图像转换为具有交错颜色信息的单通道图像
	rgb3_to_interleaved(src, &srcGray);
	//WriteImage(srcGray, "jpg", 0, "srcGray.jpg");
	GetImagePointer1(srcGray, &hv_Pointer, &hv_Type, &hv_Width, &hv_Height); //获取单通道图像指针
}
else
{
	GetImagePointer1(src, &hv_Pointer, &hv_Type, &hv_Width, &hv_Height);//获取单通道图像指针
}

 //2.获取图像信息
 Corp_message src_data; //自定义结构体

 src_data.img_num = 1;
 src_data.src.channels = hv_Channels.I();
 src_data.src.imageHeight = hv_Height.I();
 src_data.src.imageWidth = hv_Width.I();
 src_data.src.image_data = (void*)hv_Pointer.L();

//3. 根据图像信息生成图像
 if (src_data.src.channels == 1) //单通道图像生成
{
        if ((src_data.src.imageHeight > 1) && (src_data.src.imageWidth > 1) && (src_data.src.image_data != NULL))
        {
            
            hImage.GenImage1("byte", src_data.src.imageWidth, src_data.src.imageHeight, src_data.src.image_data);
            //hImage.WriteImage("jpg", 0, "1.jpg");                        
        }

    hGrayImage = hImage.CopyImage();
}
else  //多通道图像生成
{
        if ((src_data.src.imageHeight > 1) && (src_data.src.imageWidth > 1) && (src_data.src.image_data != NULL))
        {
            //hImage.GenImageInterleaved(src_data.src.image_data, "rgb", src_data.src.imageWidth, src_data.src.imageHeight, 0, "byte", src_data.src.imageWidth, src_data.src.imageHeight, 0, 0, 8, 0);
            hImage.GenImageInterleaved(src_data.src.image_data, "rgb", src_data.src.imageWidth/3, src_data.src.imageHeight, -1, "byte", 0, 0, 0, 0, -1, 0);
            hImage.WriteImage("jpg", 0, "2.jpg");
        }
    hGrayImage = hImage.Rgb1ToGray();
    hGrayImage.WriteImage("jpg", 0, "3.jpg");
}

使用 rgb3_to_interleaved() 将三通道彩色图像转换为具有交错颜色信息的单通道图像：

// 将三通道彩色图像转换为具有交错颜色信息的单通道图像
void rgb3_to_interleaved(HObject ho_ImageRGB, HObject* ho_ImageInterleaved)
{

    // Local iconic variables
    HObject  ho_ImageAffineTrans, ho_ImageRed, ho_ImageGreen;
    HObject  ho_ImageBlue, ho_RegionGrid, ho_RegionMoved, ho_RegionClipped;

    // Local control variables
    HTuple  hv_PointerRed, hv_PointerGreen, hv_PointerBlue;
    HTuple  hv_Type, hv_Width, hv_Height, hv_HomMat2DIdentity;
    HTuple  hv_HomMat2DScale;

    GetImagePointer3(ho_ImageRGB, &hv_PointerRed, &hv_PointerGreen, &hv_PointerBlue,
        &hv_Type, &hv_Width, &hv_Height);
    GenImageConst(&(*ho_ImageInterleaved), "byte", hv_Width * 3, hv_Height);
    //
    HomMat2dIdentity(&hv_HomMat2DIdentity);
    HomMat2dScale(hv_HomMat2DIdentity, 1, 3, 0, 0, &hv_HomMat2DScale);
    AffineTransImageSize(ho_ImageRGB, &ho_ImageAffineTrans, hv_HomMat2DScale, "constant",
        hv_Width * 3, hv_Height);
    //
    Decompose3(ho_ImageAffineTrans, &ho_ImageRed, &ho_ImageGreen, &ho_ImageBlue);
    GenGridRegion(&ho_RegionGrid, 2 * hv_Height, 3, "lines", hv_Width * 3, hv_Height + 1);
    MoveRegion(ho_RegionGrid, &ho_RegionMoved, -1, 0);
    ClipRegion(ho_RegionMoved, &ho_RegionClipped, 0, 0, hv_Height - 1, (3 * hv_Width) - 1);

    ReduceDomain(ho_ImageRed, ho_RegionClipped, &ho_ImageRed);
    MoveRegion(ho_RegionGrid, &ho_RegionMoved, -1, 1);
    ClipRegion(ho_RegionMoved, &ho_RegionClipped, 0, 0, hv_Height - 1, (3 * hv_Width) - 1);
    ReduceDomain(ho_ImageGreen, ho_RegionClipped, &ho_ImageGreen);
    MoveRegion(ho_RegionGrid, &ho_RegionMoved, -1, 2);
    ClipRegion(ho_RegionMoved, &ho_RegionClipped, 0, 0, hv_Height - 1, (3 * hv_Width) - 1);
    ReduceDomain(ho_ImageBlue, ho_RegionClipped, &ho_ImageBlue);
    OverpaintGray((*ho_ImageInterleaved), ho_ImageRed);
    OverpaintGray((*ho_ImageInterleaved), ho_ImageGreen);
    OverpaintGray((*ho_ImageInterleaved), ho_ImageBlue);
    return;
}

二、获取halcon图像的指针（C#）

C#的实现步骤和算子与C++是相同的，只是编程语言不同，下面是代码实现：

HObject src, ho_ImageInterleaved;
HOperatorSet.ReadImage(out src, "./pic/huashang.png"); //读取图像

HTuple hv_Pointer, hv_Type, hv_Width, hv_Height, hv_Channels;
HOperatorSet.CountChannels(src, out hv_Channels);  //获取图像通道数
 
if (hv_Channels.I != 1) //多通道图像指针获取
{
    // 将三通道彩色图像转换为具有交错颜色信息的单通道图像(宽度*3)。
    rgb3_to_interleaved(src, out ho_ImageInterleaved);
    //HOperatorSet.WriteImage(ho_ImageInterleaved, "png", 0, "ho_ImageInterleaved.png");
    HOperatorSet.GetImagePointer1(ho_ImageInterleaved, out hv_Pointer, out hv_Type, out hv_Width, out hv_Height);
}
else                    //单通道图像指针获取
{
    HOperatorSet.GetImagePointer1(src, out hv_Pointer, out hv_Type, out hv_Width, out hv_Height);

}

使用 rgb3_to_interleaved() 将三通道彩色图像转换为具有交错颜色信息的单通道图像：

 private void rgb3_to_interleaved(HObject ho_ImageRGB, out HObject ho_ImageInterleaved)
        {

            // Local iconic variables 

            HObject ho_ImageAffineTrans, ho_ImageRed, ho_ImageGreen;
            HObject ho_ImageBlue, ho_RegionGrid, ho_RegionMoved, ho_RegionClipped;

            // Local control variables 

            HTuple hv_PointerRed = new HTuple(), hv_PointerGreen = new HTuple();
            HTuple hv_PointerBlue = new HTuple(), hv_Type = new HTuple();
            HTuple hv_Width = new HTuple(), hv_Height = new HTuple();
            HTuple hv_HomMat2DIdentity = new HTuple(), hv_HomMat2DScale = new HTuple();

            // Initialize local and output iconic variables 
            HOperatorSet.GenEmptyObj(out ho_ImageInterleaved);
            HOperatorSet.GenEmptyObj(out ho_ImageAffineTrans);
            HOperatorSet.GenEmptyObj(out ho_ImageRed);
            HOperatorSet.GenEmptyObj(out ho_ImageGreen);
            HOperatorSet.GenEmptyObj(out ho_ImageBlue);
            HOperatorSet.GenEmptyObj(out ho_RegionGrid);
            HOperatorSet.GenEmptyObj(out ho_RegionMoved);
            HOperatorSet.GenEmptyObj(out ho_RegionClipped);
            //hv_PointerRed.Dispose(); hv_PointerGreen.Dispose(); hv_PointerBlue.Dispose(); hv_Type.Dispose(); hv_Width.Dispose(); hv_Height.Dispose();
            HOperatorSet.GetImagePointer3(ho_ImageRGB, out hv_PointerRed, out hv_PointerGreen,
                out hv_PointerBlue, out hv_Type, out hv_Width, out hv_Height);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_ImageInterleaved.Dispose();
                HOperatorSet.GenImageConst(out ho_ImageInterleaved, "byte", hv_Width * 3, hv_Height);
            }
            //
            //hv_HomMat2DIdentity.Dispose();
            HOperatorSet.HomMat2dIdentity(out hv_HomMat2DIdentity);
            //hv_HomMat2DScale.Dispose();
            HOperatorSet.HomMat2dScale(hv_HomMat2DIdentity, 1, 3, 0, 0, out hv_HomMat2DScale);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_ImageAffineTrans.Dispose();
                HOperatorSet.AffineTransImageSize(ho_ImageRGB, out ho_ImageAffineTrans, hv_HomMat2DScale,
                    "constant", hv_Width * 3, hv_Height);
            }
            //
            ho_ImageRed.Dispose(); ho_ImageGreen.Dispose(); ho_ImageBlue.Dispose();
            HOperatorSet.Decompose3(ho_ImageAffineTrans, out ho_ImageRed, out ho_ImageGreen,out ho_ImageBlue);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_RegionGrid.Dispose();
                HOperatorSet.GenGridRegion(out ho_RegionGrid, 2 * hv_Height, 3, "lines", hv_Width * 3,
                    hv_Height + 1);
            }
            ho_RegionMoved.Dispose();
            HOperatorSet.MoveRegion(ho_RegionGrid, out ho_RegionMoved, -1, 0);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_RegionClipped.Dispose();
                HOperatorSet.ClipRegion(ho_RegionMoved, out ho_RegionClipped, 0, 0, hv_Height - 1,(3 * hv_Width) - 1);
            }

            {
                HObject ExpTmpOutVar_0;
                HOperatorSet.ReduceDomain(ho_ImageRed, ho_RegionClipped, out ExpTmpOutVar_0);
                ho_ImageRed.Dispose();
                ho_ImageRed = ExpTmpOutVar_0;
            }
            ho_RegionMoved.Dispose();
            HOperatorSet.MoveRegion(ho_RegionGrid, out ho_RegionMoved, -1, 1);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_RegionClipped.Dispose();
                HOperatorSet.ClipRegion(ho_RegionMoved, out ho_RegionClipped, 0, 0, hv_Height - 1,
                    (3 * hv_Width) - 1);
            }
            {
                HObject ExpTmpOutVar_0;
                HOperatorSet.ReduceDomain(ho_ImageGreen, ho_RegionClipped, out ExpTmpOutVar_0
                    );
                ho_ImageGreen.Dispose();
                ho_ImageGreen = ExpTmpOutVar_0;
            }
            ho_RegionMoved.Dispose();
            HOperatorSet.MoveRegion(ho_RegionGrid, out ho_RegionMoved, -1, 2);
            using (HDevDisposeHelper dh = new HDevDisposeHelper())
            {
                ho_RegionClipped.Dispose();
                HOperatorSet.ClipRegion(ho_RegionMoved, out ho_RegionClipped, 0, 0, hv_Height - 1,
                    (3 * hv_Width) - 1);
            }
            {
                HObject ExpTmpOutVar_0;
                HOperatorSet.ReduceDomain(ho_ImageBlue, ho_RegionClipped, out ExpTmpOutVar_0);
                ho_ImageBlue.Dispose();
                ho_ImageBlue = ExpTmpOutVar_0;
            }
            HOperatorSet.OverpaintGray(ho_ImageInterleaved, ho_ImageRed);
            HOperatorSet.OverpaintGray(ho_ImageInterleaved, ho_ImageGreen);
            HOperatorSet.OverpaintGray(ho_ImageInterleaved, ho_ImageBlue);
            ho_ImageAffineTrans.Dispose();
            ho_ImageRed.Dispose();
            ho_ImageGreen.Dispose();
            ho_ImageBlue.Dispose();
            ho_RegionGrid.Dispose();
            ho_RegionMoved.Dispose();
            ho_RegionClipped.Dispose();

            //hv_PointerRed.Dispose();
            //hv_PointerGreen.Dispose();
            //hv_PointerBlue.Dispose();
            //hv_Type.Dispose();
            //hv_Width.Dispose();
            //hv_Height.Dispose();
            //hv_HomMat2DIdentity.Dispose();
            //hv_HomMat2DScale.Dispose();

            return;
        }
halcon生成图像gen_image_xxx函数
m0_37737957的博客
02-11 842
一、gen_image_gray_ramp 二、gen_image_surface_first_order 三、gen_image_surface_second_order 四、gen_image_const 五、gen_image_proto 六、gen_image1 七、 gen_image1_extern 八、 gen_image1_rect 九、gen_image3 十、gen_image3_extern 十一、gen_image_interleaved
Halcon 图像类型转换
最新发布
LIN943168247的博客
04-22 160
各位朋友们好，我是大脸猫。在计算机视觉开发中，经常需要将 Halcon 的 hobject 图像类型与 Mat 进行交互处理。然而，Halcon 和 Mat 在图像数据结构和存储方式上存在差异，直接使用会遇到诸多不便。因此，实现 hobject 到 Mat 的转换功能，成为打通两者高效协作的关键环节，对后续的图像分析与处理起着重要的铺垫作用。
halcon get_image_pointer1获取图像指针
优快云博客
07-15 8886
get_image_pointer1（算子） get_image_pointer1 - 访问单通道图像的指针。 get_image_pointer1(Image : : : Pointer, Type, Width, Height) 描述 运算符get_image_pointer1返回指向图像Image的第一个通道的指针。此外，返回图像类型（Type =‘byte’，‘int2’，'uint2’...
HALCON算子【图像操作】`get_image_pointer1 ` 和 `get_image_pointer3`
专注于 Qt/C++ 应用开发和机器视觉领域的开源项目分享。期待与您共同进步！
03-14 564
在使用 HALCON 进行图像处理时，我们通常使用其自带的图像处理算子来操作图像。但是在某些情况下，我们希望直接访问图像数据进行高效处理，这时候 get_image_pointer1 和 get_image_pointer3 这两个算子就能派上用场。它们的作用是 获取图像数据的指针，让我们可以直接读取或修改像素值。
halcon指针生成Hobject图像
u014090257的博客
04-29 3341
//ImageWidth：图像宽度 //ImageHeight:图像高度 //R_Outptr: 红色通道图像数据流 //G_Outptr: 红色通道图像数据流 //B_Outptr: 红色通道图像数据流 //返回值:HObject对象 public HObject ImagePtrToHobject(int ImageWidth, int ImageHeight, ref byte[...
利用halcon读取tiff图像，并且获取图像指针
十方御道的博客
11-06 3723
// read_tif.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <halconcpp/HalconCpp.h> #include <halconcpp/HDevThread.h> #include <opencv.hpp> #include <vector> #include &l...
Halcon--指针识别
Doctor__Chen的博客
12-10 3370
文章目录前言一、思路二、测试--结果三、源码总结 前言 基于Halcon的指针识别 一、思路 首先从原图像中选择一块多边形区域，使之包围指针部分，将该区域分割出来，作为参考的形状模板；接着确定形状模板的金字塔层的级数和对比度参数；然后创建形状模板，并检查创建出的形状模板轮廓是否理想；最后，读取检查图像进行模板匹配，从图像上获取指针形状的位置坐标和旋转角度。 二、测试–结果 三、源码 *指针识别 *清空显示窗口 dev_close_window() *读取模板图像。这里的模板图像是单通道灰度图像，
Halcon绘制图形
一个不掉头发的资深小白
03-14 1475
Halcon中的ROI可以通过不同的方式定义，比如矩形、圆形、多边形等形状，也可以由用户手动绘制。ROI可以用于在图像上截取特定区域，或者在某些算法中限定处理的范围。
halcon获取图像中心点_Halcon学习之一：查询和获取图像
weixin_34550555的博客
01-14 2819
1、get_grayval(Image::Row,Column:Grayval)计算Image图像中坐标为(Row，Column)的点的灰度值Grayval。2、get_image_pointer1(Image:::Pointer,Type,Width,Height)计算Image图像的数据指针Pointer，图像类型Type，图像宽度Width和高度Heig...
halcon创建图像/设置图像像素值/获取像素值/保存图像/加载图像
大兵小杰
08-29 6190
//1.创建一通道图像 HTuple hType("byte"); //定义图像像素类型 HTuple hWidth(600); //定义图像宽度为400 HTuple hHeight(300); //定义图像高度为300 //方式1:利用构造函数, 创建一张1通道黑色图片 HImage hImage1(hType, hWidth, hHeight); hImage1.WriteImage("bmp", 0, "/home/mark/Desktop/hImage1.bmp"); ...
halcon和c++之间的图像数据转换
08-08
处理完蓝色通道后，我们使用`GenImage3`函数创建一个新的HObject ho_ImageRGB，该函数允许我们基于原始图像类型、宽度、高度以及修改后的颜色通道指针生成一个新的图像对象。这使得我们可以继续使用HALCON的其他算子...
指针仪表识别halcon代码
09-06
用halcon11写的指针仪表识别代码，在C#和VB都开发了软件
halcon 水表读数 指针识别 OCR
11-24
可识别水表显示数字和指针所指数值。VS2017结合halcon，C#语言编程。
Halcon如何创建或生成空白的，全黑或全白的8位图和24位图
$firecat利白的代码足迹$
07-05 1万+
直接上源码： gen_image_const(Image, 'byte', 512, 512)//生成一个图像，用byte格式 gen_image_proto(Image, ImageR, 255)//生成第一通道图像 gen_image_proto(Image, ImageG, 0)//生成第二通道图像 gen_image_proto(Image, ImageB, 0)//生成第三通道图像 compose3(ImageR, ImageG, ImageB, MultiImage)//合成三个通道图像 s
halcon 图像合成与通道
zhanghebin1010的博客
09-14 1449
halcon 通道分离与合并
Halcon vc学习1-图像数据获取、加载
zcrong的专栏
06-25 2310
vc添加Halcon库的引用： #include "HalconCpp.h" #pragma  comment(lib,"halconcpp.lib")   //----------------------------------------------------- #include "stdafx.h" #include "HalconCpp.h"   using name
Halcon学习之四：有关图像生成的函数
热门推荐
xinrui_ekitty的技术专栏
01-06 1万+
图像生成
c语言getimage,HALCON算子描述：get_image_pointer1
weixin_39925098的博客
05-23 459
名字get_image_pointer1 获取一个通道的Pointer(指示器)函数签名get_image_pointer1(Image : : : Pointer, Type, Width, Height)图像对象输出为空，控制输入参数为空。描述这个算子返回输入图像对象Image的第一个通道的Pointer(指示器)。另外，这个算子也返回图像类型和图像的大小(width和height)。这样的话...
halcon GenImageInterleaved、
12-28
### Halcon `GenImageInterleaved` 函数详解 #### 函数定义 `GenImageInterleaved` 是用于生成多通道图像的功能。该函数允许用户指定不同颜色分量的数据来构建一个多通道的图像对象。 #### 参数描述 - **ChannelData** (输入控制)：包含各通道像素值的一维数组或多行一列矩阵。 - **Channels** (输入控制)：字符串列表，表示各个通道的颜色名称（如 "red", "green", "blue"）。支持的标准通道名有："gray", "red", "green", "blue", "alpha", "hue", "saturation", "value". - **Width** (输入控制)：图像宽度。 - **Height** (输入控制)：图像高度。 - **Image** (输出)：生成的多通道图像对象。 此函数特别适用于从外部源读取彩色或其他类型的多通道图像数据，并将其转换成可以在 HALCON 中进一步处理的形式[^1]。 #### 示例代码 下面是一个简单的 Python 脚本示例，展示了如何利用 HALCON 的 `gen_image_interleaved()` 方法创建一个 RGB 图像： ```python from pyhalcon import * # 初始化HALCON环境 set_system('no_message_dialog', 'true') # 定义每个通道的数据(这里简化为随机数) width, height = 200, 150 channel_data = [] for _ in range(height * width): channel_data.extend([random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)]) # 创建RGB图像 image_rgb = gen_image_interleaved(channel_data, ['red', 'green', 'blue'], width, height) # 显示图像 disp_obj(image_rgb, get_window_attr('window')) ``` 上述脚本首先设置了 HALCON 不弹出消息对话框；接着准备了一些模拟的色彩数据作为三个独立的通道；最后调用了 `gen_image_interleaved()` 来组合这些数据形成一张完整的 RGB 彩色图片并显示出来。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值