C#+Halcon调用Basler相机

最新推荐文章于 2023-05-18 12:45:51 发布
最新推荐文章于 2023-05-18 12:45:51 发布
阅读量8.8k 收藏 113
点赞数 26
分类专栏： 相机的连接 文章标签： Basler相机的连接
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44490080/article/details/100298807
版权

Basler调用类：

ps：这个类经我手删删减减精简出来的一个Basler相机调用的类。后边有它的简单演示，也不演示过多的东西

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;

using HalconDotNet;
using Basler.Pylon;

namespace Basler相机的调用
{
    class BaslerClass
    {
        private Camera camera = null;
        private PixelDataConverter converter = new PixelDataConverter();
        private string strUserID = null;

        public long imageWidth = 0;         // 图像宽
        public long imageHeight = 0;        // 图像高
        public long minExposureTime = 0;    // 最小曝光时间
        public long maxExposureTime = 0;    // 最大曝光时间
        public long minGain = 0;            // 最小增益
        public long maxGain = 0;            // 最大增益
        private long grabTime = 0;          // 采集图像时间

        private HObject hPylonImage = null;
        private IntPtr latestFrameAddress = IntPtr.Zero;
        private Stopwatch stopWatch = new Stopwatch();

        /// <summary>
        /// 计算采集图像时间自定义委托
        /// </summary>
        /// <param name="time">采集图像时间</param>
        public delegate void delegateComputeGrabTime(long time);
        /// <summary>
        /// 计算采集图像时间委托事件
        /// </summary>
        public event delegateComputeGrabTime eventComputeGrabTime;

        /// <summary>
        /// 图像处理自定义委托
        /// </summary>
        /// <param name="hImage">halcon图像变量</param>
        public delegate void delegateProcessHImage(HObject hImage);
        /// <summary>
        /// 图像处理委托事件
        /// </summary>
        public event delegateProcessHImage eventProcessImage;

        /// <summary>
        /// if >= Sfnc2_0_0,说明是ＵＳＢ３的相机
        /// </summary>
        static Version Sfnc2_0_0 = new Version(2, 0, 0);


        /******************    实例化相机    ******************/
        /// <summary>
        /// 实例化第一个找到的相机
        /// </summary>
        public BaslerClass()
        {
            try
            {
                camera = new Camera();
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }
        /// <summary>
        /// 根据相机UserID实例化相机
        /// </summary>
        /// <param name="UserID"></param>
        public BaslerClass(string UserID)
        {
            try
            {
                strUserID = UserID;
                // 枚举相机列表
                List<ICameraInfo> allCameraInfos = CameraFinder.Enumerate();

                foreach (ICameraInfo cameraInfo in allCameraInfos)
                {
                    if (strUserID == cameraInfo[CameraInfoKey.UserDefinedName])
                    {
                        camera = new Camera(cameraInfo);
                    }
                }

                if (camera == null)
                {
                    MessageBox.Show("未识别到UserID为“" + strUserID + "”的相机！", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }

        //清除图像处理委托事件绑定的方法
        public void Clear_EventProcessImage_Event()
        {
            if (eventProcessImage != null)
            {

                Delegate[] dels = eventProcessImage.GetInvocationList();
                foreach (Delegate d in dels)
                {
                    //得到方法名
                    object delObj = d.GetType().GetProperty("Method").GetValue(d, null);
                    string funcName = (string)delObj.GetType().GetProperty("Name").GetValue(delObj, null);
                    Debug.Print(funcName);
                    eventProcessImage -= d as delegateProcessHImage;
                }
            }
        }
        /*****************************************************/

        /******************    相机操作     ******************/
        /// <summary>
        /// 打开相机
        /// </summary>
        public bool OpenCam()
        {
            try
            {
                camera.Open();
                imageWidth = camera.Parameters[PLCamera.Width].GetValue();               // 获取图像宽 
                imageHeight = camera.Parameters[PLCamera.Height].GetValue();              // 获取图像高
                GetMinMaxExposureTime();
                GetMinMaxGain();
                camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;                      // 注册采集回调函数
                camera.ConnectionLost += OnConnectionLost;
            }
            catch (Exception e)
            {
                return false;
            }
            return true;
        }
        /// <summary>
        /// 关闭相机,释放相关资源
        /// </summary>
        public void CloseCam()
        {
            try
            {
                camera.Close();
                camera.Dispose();

                if (hPylonImage != null)
                {
                    hPylonImage.Dispose();
                }

                if (latestFrameAddress != null)
                {
                    Marshal.FreeHGlobal(latestFrameAddress);
                    latestFrameAddress = IntPtr.Zero;
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }
        /// <summary>
        /// 相机是否忙碌中
        /// </summary>
        public bool isBusy()
        {
            return camera.StreamGrabber.IsGrabbing;
        }

        /// <summary>
        /// 单张采集
        /// </summary>
        public bool GrabOne()
        {
            try
            {
                if (camera.StreamGrabber.IsGrabbing)
                {
                    MessageBox.Show("Camera is now Continue Grabing Images！", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return false;
                }
                else
                {
                    camera.Parameters[PLCamera.AcquisitionMode].SetValue("SingleFrame");
                    camera.StreamGrabber.Start(1, GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
                    stopWatch.Restart();
                    return true;
                }
            }
            catch (Exception e)
            {
                ShowException(e);
                return false;
            }
        }

        /// <summary>
        /// 开始连续采集
        /// </summary>
        public bool StartGrabbing()
        {
            try
            {
                if (camera.StreamGrabber.IsGrabbing)
                {
                    MessageBox.Show("Camera is now Continue Grabing Images", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return false;
                }
                else
                {
                    camera.Parameters[PLCamera.AcquisitionMode].SetValue(PLCamera.AcquisitionMode.Continuous);
                    camera.StreamGrabber.Start(GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
                    stopWatch.Restart();
                    return true;
                }
            }
            catch (Exception e)
            {
                ShowException(e);
                return false;
            }
        }

        /// <summary>
        /// 停止连续采集
        /// </summary>
        public void StopGrabbing()
        {
            try
            {
                if (camera.StreamGrabber.IsGrabbing)
                {
                    camera.StreamGrabber.Stop();
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }
        /*********************************************************/

        /******************    相机参数设置   ********************/
        /// <summary>
        /// 设置Gige相机心跳时间
        /// </summary>
        /// <param name="value"></param>
        public void SetHeartBeatTime(long value)
        {
            try
            {
                // 判断是否是网口相机
                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    camera.Parameters[PLGigECamera.GevHeartbeatTimeout].SetValue(value);
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }

        /// <summary>
        /// 设置相机曝光时间
        /// </summary>
        /// <param name="value"></param>
        public void SetExposureTime(long value)
        {
            try
            {
                //要手动设置曝光时间 需要把自动曝光参数设置为false  把相机曝光模式设置为延时曝光模式
                camera.Parameters[PLCamera.ExposureAuto].TrySetValue(PLCamera.ExposureAuto.Off);
                camera.Parameters[PLCamera.ExposureMode].TrySetValue(PLCamera.ExposureMode.Timed);

                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    long min = camera.Parameters[PLCamera.ExposureTimeRaw].GetMinimum();
                    long max = camera.Parameters[PLCamera.ExposureTimeRaw].GetMaximum();
                    long incr = camera.Parameters[PLCamera.ExposureTimeRaw].GetIncrement();
                    if (value < min)
                    {
                        value = min;
                    }
                    else if (value > max)
                    {
                        value = max;
                    }
                    else
                    {
                        value = min + (((value - min) / incr) * incr);
                    }
                    camera.Parameters[PLCamera.ExposureTimeRaw].SetValue(value);
                }
                else
                {
                    camera.Parameters[PLUsbCamera.ExposureTime].SetValue((double)value);
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }

        /// <summary>
        /// 获取最小最大曝光时间
        /// </summary>
        public void GetMinMaxExposureTime()
        {
            try
            {
                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    minExposureTime = camera.Parameters[PLCamera.ExposureTimeRaw].GetMinimum();
                    maxExposureTime = camera.Parameters[PLCamera.ExposureTimeRaw].GetMaximum();
                }
                else
                {
                    minExposureTime = (long)camera.Parameters[PLUsbCamera.ExposureTime].GetMinimum();
                    maxExposureTime = (long)camera.Parameters[PLUsbCamera.ExposureTime].GetMaximum();
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }

        /// <summary>
        /// 设置增益
        /// </summary>
        /// <param name="value"></param>
        public void SetGain(long value)
        {
            try
            {
                camera.Parameters[PLCamera.GainAuto].TrySetValue(PLCamera.GainAuto.Off);

                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    long min = camera.Parameters[PLCamera.GainRaw].GetMinimum();
                    long max = camera.Parameters[PLCamera.GainRaw].GetMaximum();
                    long incr = camera.Parameters[PLCamera.GainRaw].GetIncrement();
                    if (value < min)
                    {
                        value = min;
                    }
                    else if (value > max)
                    {
                        value = max;
                    }
                    else
                    {
                        value = min + (((value - min) / incr) * incr);
                    }
                    camera.Parameters[PLCamera.GainRaw].SetValue(value);
                }
                else
                {
                    camera.Parameters[PLUsbCamera.Gain].SetValue(value);
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }

        /// <summary>
        /// 获取最小最大增益
        /// </summary>
        public void GetMinMaxGain()
        {
            try
            {
                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    minGain = camera.Parameters[PLCamera.GainRaw].GetMinimum();
                    maxGain = camera.Parameters[PLCamera.GainRaw].GetMaximum();
                }
                else
                {
                    minGain = (long)camera.Parameters[PLUsbCamera.Gain].GetMinimum();
                    maxGain = (long)camera.Parameters[PLUsbCamera.Gain].GetMaximum();
                }
            }
            catch (Exception e)
            {
                ShowException(e);
            }
        }
        /****************************************************/


        /****************  图像响应事件函数  ****************/


        // 相机取像回调函数.
        private void OnImageGrabbed(Object sender, ImageGrabbedEventArgs e)
        {
            try
            {
                IGrabResult grabResult = e.GrabResult;
                if (grabResult.GrabSucceeded)
                {
                    grabTime = stopWatch.ElapsedMilliseconds;
                    {
                        if (latestFrameAddress == IntPtr.Zero)
                        {
                            latestFrameAddress = Marshal.AllocHGlobal((Int32)grabResult.PayloadSize);
                        }
                        converter.OutputPixelFormat = PixelType.Mono8;
                        converter.Convert(latestFrameAddress, grabResult.PayloadSize, grabResult);
                        // 转换为Halcon图像显示
                        HOperatorSet.GenImage1(out hPylonImage, "byte", (HTuple)grabResult.Width, (HTuple)grabResult.Height, (HTuple)latestFrameAddress);
                        // 抛出图像处理事件
                        eventProcessImage(hPylonImage);
                        hPylonImage.Dispose();
                    }
                }
                else
                {
                    MessageBox.Show("Grab faild!\n" + grabResult.ErrorDescription, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            catch (Exception exception)
            {
                ShowException(exception);
            }
            finally
            {
                e.DisposeGrabResultIfClone();
            }
        }

        /****************************************************/


        /// <summary>
        /// 掉线重连回调函数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnConnectionLost(Object sender, EventArgs e)
        {
            try
            {
                camera.Close();

                for (int i = 0; i < 100; i++)
                {
                    try
                    {
                        camera.Open();
                        if (camera.IsOpen)
                        {
                            MessageBox.Show("已重新连接上UserID为“" + strUserID + "”的相机！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
                            break;
                        }
                        Thread.Sleep(200);
                    }
                    catch
                    {
                        MessageBox.Show("请重新连接UserID为“" + strUserID + "”的相机！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }

                if (camera == null)
                {
                    MessageBox.Show("重连超时20s:未识别到UserID为“" + strUserID + "”的相机！", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                SetHeartBeatTime(5000);
                imageWidth = camera.Parameters[PLCamera.Width].GetValue();               // 获取图像宽 
                imageHeight = camera.Parameters[PLCamera.Height].GetValue();              // 获取图像高
                GetMinMaxExposureTime();
                GetMinMaxGain();
                camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;                      // 注册采集回调函数
                camera.ConnectionLost += OnConnectionLost;

            }
            catch (Exception exception)
            {
                ShowException(exception);
            }
        }
        private void ShowException(Exception exception)
        {
            MessageBox.Show("Exception caught:\n" + exception.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}

演示：

环境准备：

项目目录：

引用文件：

Basler.Pylon.dll

halcondontnet.dll

 

Winform布局：

代码：

using HalconDotNet;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Basler相机的调用
{
    public partial class Form1 : Form
    {
        //实例化相机
        private static BaslerClass basler;
        public Form1()
        {
            InitializeComponent();
            Loader_Form1();
        }
        private void Loader_Form1() {
            basler = new BaslerClass();
            if (basler.OpenCam())
            {
                //设置相机心跳时间
                basler.SetHeartBeatTime(10000);
                MessageBox.Show("相机连接成功！");
                //绑定图片显示的回调函数
                basler.eventProcessImage += show_Image;
                //初始化trackBar控件
                trackBar1.Minimum = 0;
                trackBar1.Maximum = 50;
                trackBar1.TickFrequency = 1;
            }
            else
            {
                MessageBox.Show("未连接到相机！");
            }
        }
        //单采集
        private void button1_Click(object sender, EventArgs e)
        {
            basler.GrabOne();
        }
        //连续采集
        private void button2_Click(object sender, EventArgs e)
        {
            basler.StartGrabbing();
        }
        //停止采集
        private void button3_Click(object sender, EventArgs e)
        {
            basler.StopGrabbing();
        }
        //设置增益
        private void set_Gain(object sender, EventArgs e) {
            long value = trackBar1.Value;
            basler.SetGain(value);
        }
        //在halcon控件中显示图像
        private void show_Image(HObject ho_Image) {
            HTuple hv_Height = null, hv_Width = null, hv_WinHandle = this.hWindowControl1.HalconWindow;
            
            if (ho_Image != null)
            {
                HOperatorSet.GetImageSize(ho_Image, out hv_Width, out hv_Height);
                HOperatorSet.SetPart(hv_WinHandle, 0, 0, hv_Height, hv_Width);
                HOperatorSet.DispObj(ho_Image, hv_WinHandle);
            }
        }
    }
}

效果：

注意：trackBar控件需要绑定ValueChanged事件

拔掉相机网线后：

aaaaabin
关注
  • 26
    点赞
  • 踩
  • 113
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
使用c#连接Basler相机，halcon显示采集图像
wei1314520qwe的博客
12-01 1541
本内容提高给初学者小白练习如何连接相机采集，仅供学习使用
基于qt平台的halcon读图的basler相机调用
06-14
在本文中，我们将深入探讨如何在Qt平台上使用Halcon库来调用Basler相机进行图像采集。首先，我们要理解三个核心概念：Qt、Halcon和Basler相机。 Qt是一个跨平台的应用程序开发框架，广泛应用于GUI（图形用户界面）...
Basler外部触发C#.cs
07-05
Halcon与C#联合编程，实现Basler相机的外部触发回调函数，通过 set_framegrabber_callback 算子注册回调函数。
Basler_Gige面阵相机C#基于Halcon显示的SDK采图工具
10-12
* Basler Gige相机：Basler_pylon_5.0.12.11830 * 相机软件SDK自带动态库：PylonC.NET.dll、PylonC.NETSupportLibrary.dll、PylonC_MD_VC120_v5_0.dll * * 编译环境：Visual Studio 2013 * .Net版本：.Net Framework 4.5 * Halcon版本：12.03 * * 实现功能：相机连接、采集图像(单帧采集、连续采集)，软触发，曝光&增益设置、读取，图像缩放功能 * * BaslerCamera.cs：相机类 * Tools.cs：工具类
C#基于Halcon实现Basler相机采图SDK
09-27
使用Basler相机软件自带动态库，相机软件版本Basler_pylon_5.0.12.11830，为了Demo可以正常运行，建议安装推荐版本的相机软件。
Basler相机Sdk采图的演示例程（C#）
soinlove36的专栏
11-06 2945
Basler相机Sdk采图的演示例程
【basler】Chapter5：basler相机C#代码实现与详解
chotin的博客
01-12 6263
1、简介 最近使用basler相机，摸索了一段时间，找过一些其他的代码，有的不管用，有的只能拍照，无法处理相片流。其中有一个博客代码简洁明了，可以做入门学习，但是只能拍照不能录像： https://blog.csdn.net/gy0124/article/details/103469354 以下将介绍可以实现拍照、录像功能的代码。 2、basler C# demo using System; us...
basler采图转halcon显示的程序
12-28
由于Basler相机捕获的图像数据格式可能与Halcon要求的格式不一致，因此需要在C#程序中进行转换。这可能涉及到色彩空间转换、位深度调整等步骤，确保Halcon能够正确解析和处理图像。 6. **Halcon显示图像**： 在...
halcon联合C#实现图像实时采集（使用BaslerSDK）
12-28
主要功能包括：单张采集、连续采集、停止采集、切换软硬触发模式，设置曝光、增益，加载、保存图片，采集图像计数、计时等。...自己引用对应版本的halcon即可，默认是halcon10，64位程序 PS：资源仅供交流
basler相机demo
06-25
Basler相机是一款在工业自动化、机器视觉等领域广泛应用的高性能相机。这个"basler相机demo"是基于Qt框架在Visual Studio 2019环境下开发的一个示例程序，它提供了Basler相机的基本操作功能，便于用户进行二次开发。...
halcon外触发get_framegrabber_callback注册回调函数方法
09-27
halcon外触发get_framegrabber_callback注册回调函数方法，c#代码
c#网口相机外触发SetFramegrabberCallback回调采图
09-29
c#海康网口相机外触发SetFramegrabberCallback回调采图，对于飞拍很有用 SetFramegrabberCallback的好处： 1，使用halcon自带的采集接口，避免了图像转换，采集效率高于SDK 2，避免了用户端轮询采集，资源占用少 3，接口通用，只要相机支持对应的事件回调，模块化更加容易 运行环境：vs2017,halcon17.12
basler相机的C#封装_
12-09
basler相机使用C#封装： C#封装basler，获取bitmap及hobject图像，内触发、外触发、获取单帧
C#应用halcon对Basler相机外部触发设置
星河队长
10-18 4240
一、相机硬件接线图 2号引脚接传感器的触发信号引脚，5号与传感器共地连接。 二、pylon软件设置 三、halcon软触发相机拍照 Halcon采集助手设置软触发： 1.set_framegrabber_param (AcqHandle, ‘TriggerMode’, ‘On’) 2.set_framegrabber_param (AcqHandle, ‘TriggerSource’, ‘S...
C#、打开basler相机
星河队长
12-10 5479
使用到了Basler的相机，利用C#编写的SDK，下面进行简单的整理记录。 首先引用basler的动态库文件，具体引用位置如下： 安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll ———————————————— 版权声明：本文为CSDN博主「大_樱_桃」的原创文章，遵循 CC 4.0 BY-S...
C# 获取baser工业相机
john_and_jane的博客
05-18 829
C#开发获取并设置baser相机
Halcon连接相机采集图像(Basler相机)
苏林同学的博客
01-06 9414
1，用网线把basler相机接到电脑上，配置相机 2，电脑右下角右键单击，选择“打开网络和共享中心” 3，如下图操作 4，打开basler相机的IPConfigurator,如下图配置，这里配置的IP与上面填写的IP需在同一网段 配置点Ok后state显示ok说明相机配置成功，现在可以正常使用相机了 5，打开Halcon软件，助手-》Image Aquisition 01 ......
basler相机曝光时间，增益等参数设置
热门推荐
草帽小子的博客
03-01 1万+
参考：http://blog.csdn.net/liyuanbhu/article/details/74841591 参考：http://blog.csdn.net/cocoasprite/article/details/60955012 一、 在设置相机参数之前，先要获取相机对象。Pylon::CTlFactory 具有一个 CreateDevice() 方法可以用来生成一个相机对象，并返回一个...
c#+halcon视觉框架
最新发布
07-13
c是英文字母表中的第三个字母。在中文中，c通常用来表示“中心”的意思，也可以代表“聪明”、“可爱”、“充满活力”等含义。此外，在计算机领域中，c也是一种编程语言的名称，它是一种高级语言，被广泛应用于软件开发和计算机科学领域。 在数学中，c通常用来表示复数的虚部，例如a+bi，其中i为虚数单位。c也有着许多重要的数学和物理上的应用，比如光速常数c代表的是真空中的光速，是一个不变的物理常数，其数值为299,792,458米每秒。 此外，在音乐中，c是一个音符，它通常代表着一个特定的音高。在西方音乐中，乐谱用字母表示音符，c代表的是do音。 总的来说，c字母代表了许多不同的意义和用途，在不同的领域中都有着特定的含义和符号。无论是作为一个字母、一个词汇还是一个符号，c都在不同的语境中承载了丰富多样的意义和用途。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值