C# 连接basler相机

已于 2022-11-24 17:40:47 修改
阅读量5.6k 收藏 51
点赞数 5
分类专栏： 相机 C# 文章标签： c# 开发语言
于 2019-10-07 20:50:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44713908/article/details/102327656
版权
C# 同时被 2 个专栏收录
64 篇文章 13 订阅
订阅专栏
相机
3 篇文章 2 订阅
订阅专栏 

 /// <summary>
    /// 巴斯勒SDK
    /// </summary>
    public class SDK_Basler : SDK_Camera
    {

       // private Stopwatch stopWatch = new Stopwatch();
        /// <summary>
        /// 相机图像事件
        /// </summary>
        public override event ImageDelegate Image_Delegate;
      
        /// <summary>
        /// 相机实例
        /// </summary>
        private Camera camera = null;
        /// <summary>
        /// 相机名称
        /// </summary>
        private string Cam_name;

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

        private PixelDataConverter converter = new PixelDataConverter();
        private IntPtr latestFrameAddress = IntPtr.Zero;
        /// <summary>
        /// 是否已连接相机
        /// </summary>
        public override bool IsOpen
        {
            get {
                if (camera!=null)
                {
                    return camera.IsOpen;
                }
                return false;
            }        
        }
        /// <summary>
        /// 实时采集
        /// </summary>
        public override void Acquisition()
        {
            if (camera != null)
            {
                if ("On"==camera.Parameters[PLCamera.TriggerMode].GetValue())
                {
                    SetTriggerMode(TriggerMode.Off);
                }
                //在抓取中返回true
                if (camera.StreamGrabber.IsGrabbing)
                {
                    // camera.StreamGrabber.Stop();
                    return;
                }
                camera.Parameters[PLCamera.AcquisitionMode].SetValue(PLCamera.AcquisitionMode.Continuous);
                camera.StreamGrabber.Start(GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
                // stopWatch.Restart();
            }
        }
        /// <summary>
        /// 关闭实时采集
        /// </summary>
        public override void CloseConsecutive()
        {
            if (camera != null)
            {
                if (camera.StreamGrabber.IsGrabbing)
                {
                    camera.StreamGrabber.Stop();                   
                }               
            }
        }
        /// <summary>
        /// 关闭相机
        /// </summary>
        public override void Close_Camera()
        {
            if (camera != null)
            {
                CloseConsecutive();
                //抓取图像时发生               
                camera.Close();
                camera.Dispose();
                if (latestFrameAddress != null)
                {
                    Marshal.FreeHGlobal(latestFrameAddress);
                    latestFrameAddress = IntPtr.Zero;
                }
            }
        }
        /// <summary>
        /// 设置曝光
        /// </summary>
        /// <returns></returns>
        public override double GetExposureTime()
        {
            if (camera != null)
            {                
                if (camera.Parameters.Contains(PLCamera.ExposureTimeAbs))
                {
                    return camera.Parameters[PLCamera.ExposureTimeRaw].GetValue();
                }
                else
                {
                    return camera.Parameters[PLCamera.ExposureTime].GetValue();
                }
            }
            return 0;
        }
        /// <summary>
        /// 获取增益
        /// </summary>
        /// <returns></returns>
        public override double GetGainRaw()
        {
            if (camera != null)
            {
                if (camera.Parameters.Contains(PLCamera.GainRaw))
                {
                    return camera.Parameters[PLCamera.GainRaw].GetValue();
                }
                else
                {
                    return camera.Parameters[PLCamera.Gain].GetValue();
                }
            }
            return 0;
        }
        /// <summary>
        /// 获取触发模式
        /// </summary>
        /// <returns></returns>
        public override TriggerMode GetTriggerMode()
        {
            if (camera != null)
            {
                return (TriggerMode)Enum.Parse(typeof(TriggerMode), camera.Parameters[PLCamera.TriggerMode].GetValue());
            }
            return TriggerMode.Off;
        }
        /// <summary>
        /// 获取触发源
        /// </summary>
        /// <returns></returns>
        public override TriggerSource GetTriggerSource()
        {
            if (camera != null)
            {              
                return (TriggerSource)Enum.Parse(typeof(TriggerSource), camera.Parameters[PLCamera.TriggerSource].GetValue());
            }
            return TriggerSource.Software;
        }
        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="Cam_Name"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public override bool Open_Camera(string Cam_Name)
        {
            this.Cam_name = Cam_Name;
            List<ICameraInfo> allCameras = CameraFinder.Enumerate();
            foreach (ICameraInfo item in allCameras)
            {
                //通过用户自定名称开启相机
                if (Cam_Name == item[CameraInfoKey.UserDefinedName])
                {
                    camera = new Camera(item);
                   
                   // camera.CameraOpened += Configuration.SoftwareTrigger;
                    //相机意外丢失时发生
                    camera.ConnectionLost += OnConnectionLost;
                    //连接打开时发生
                   // camera.CameraOpened += OnCameraOpened;
                    //关闭与相机的连接后发生
                    //camera.CameraClosed += OnCameraClosed;
                    //抓取会话启动后发生
                   // camera.StreamGrabber.GrabStarted += OnGrabStarted;
                    //抓取图像时发生
                    camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;
                    //捕获会话停止后发生
                    camera.StreamGrabber.GrabStopped += OnGrabStopped;
                    //打开设备
                    camera.Open();
                    //开始抓取图像
                   //  camera.StreamGrabber.Start();
                    //相机是否已打开
                    if (camera.IsOpen)
                    {                      
                        return true;
                    }
                }
            }
            return false;
        }
        /// <summary>
        /// 相机意外丢失时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnConnectionLost(Object sender, EventArgs e)
        {
            if (camera != null)
            {
                camera.Close();
                for (int i = 1; i <= 10; i++)
                {
                    camera.Open();
                    if (camera.IsOpen)
                    {
                        //camera.ConnectionLost += OnConnectionLost;
                        camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;
                        //camera.StreamGrabber.GrabStopped += OnGrabStopped;
                        return;
                    }
                    Thread.Sleep(100);
                }
            }

        }
        /// <summary>
        /// 连接打开时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnCameraOpened(Object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 连接关闭时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnCameraClosed(Object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 当相机开始抓取时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnGrabStarted(Object sender, EventArgs e)
        {

        }
        
        /// <summary>
        /// 获取图像并准备进行处理时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnImageGrabbed(Object sender, ImageGrabbedEventArgs e)
        {
            HObject Hobj;
            HOperatorSet.GenEmptyObj(out Hobj);
            //获取抓取结果
            IGrabResult grabResult = e.GrabResult;
            if (grabResult.IsValid)
            {
                //检查图像是否可以显示
                if (grabResult.GrabSucceeded)
                {
                    if (IsMonoPixelFormat(grabResult.PixelTypeValue))
                    {
                        if (latestFrameAddress == IntPtr.Zero)
                        {
                            latestFrameAddress = Marshal.AllocHGlobal((Int32)grabResult.PayloadSize);
                        }
                        converter.OutputPixelFormat = PixelType.Mono8;
                        converter.Convert(latestFrameAddress, grabResult.PayloadSize, grabResult);
                        Hobj.Dispose();
                        // 转换为Halcon图像显示
                        HOperatorSet.GenImage1(out Hobj, "byte", (HTuple)grabResult.Width, (HTuple)grabResult.Height, (HTuple)latestFrameAddress);
                    }
                    else if (grabResult.PixelTypeValue == PixelType.BayerBG8 || grabResult.PixelTypeValue == PixelType.BayerGB8
                                || grabResult.PixelTypeValue == PixelType.BayerRG8 || grabResult.PixelTypeValue == PixelType.BayerGR8)
                    {
                        int imageWidth = grabResult.Width - 1;
                        int imageHeight = grabResult.Height - 1;
                        int payloadSize = imageWidth * imageHeight;
                        if (latestFrameAddress == IntPtr.Zero)
                        {
                            latestFrameAddress = Marshal.AllocHGlobal((Int32)(3 * payloadSize));
                        }
                        converter.OutputPixelFormat = PixelType.BGR8packed;
                        // 根据bayer格式不同切换以下代码
                        converter.Parameters[PLPixelDataConverter.InconvertibleEdgeHandling].SetValue("Clip");
                        converter.Convert(latestFrameAddress, 3 * payloadSize, grabResult);
                        Hobj?.Dispose();
                        HOperatorSet.GenImageInterleaved(out  Hobj, latestFrameAddress, "bgr",(HTuple)imageWidth, (HTuple)imageHeight, -1, "byte", (HTuple)imageWidth, (HTuple)imageHeight, 0, 0, -1, 0);             
                    }
                    if (Hobj.CountObj() > 0)
                    {
                        Image_Delegate?.Invoke(Cam_name, Hobj?.Clone());
                    }
                }
            }
            Hobj?.Dispose();
            e.DisposeGrabResultIfClone();
           GC.Collect();
        }
        /// <summary>
        /// 相机停止抓取时发生
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnGrabStopped(Object sender, GrabStopEventArgs e)
        {

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="enType"></param>
        /// <returns></returns>
        private bool IsMonoPixelFormat(PixelType enType)
        {
            switch (enType)
            {
                case PixelType.Mono1packed:
                case PixelType.Mono2packed:
                case PixelType.Mono4packed:
                case PixelType.Mono8:
                case PixelType.Mono8signed:
                case PixelType.Mono10:
                case PixelType.Mono10p:
                case PixelType.Mono10packed:
                case PixelType.Mono12:
                case PixelType.Mono12p:
                case PixelType.Mono12packed:
                case PixelType.Mono16:
                    return true;
                default:
                    return false;
            }
        }
        /// <summary>
        /// 设置曝光
        /// </summary>
        /// <param name="Value"></param>
        /// <returns></returns>
        public override double SetExposureTime(double Value)
        {
            if (camera != null)
            {
                try
                {
                    camera.Parameters[PLCamera.ExposureAuto].TrySetValue(PLCamera.ExposureAuto.Off);
                    camera.Parameters[PLCamera.ExposureMode].TrySetValue(PLCamera.ExposureMode.Timed);
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        long value;
                        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 + ((((long)Value - min) / incr) * incr);
                        }
                        camera.Parameters[PLCamera.ExposureTimeRaw].SetValue(value);
                        return camera.Parameters[PLCamera.ExposureTimeRaw].GetValue();
                    }
                    else
                    {
                        if (Value <= camera.Parameters[PLUsbCamera.ExposureTime].GetMaximum() && Value >= camera.Parameters[PLUsbCamera.ExposureTime].GetMinimum())
                        {
                            camera.Parameters[PLUsbCamera.ExposureTime].SetValue((long)Value);                           
                        }
                        return camera.Parameters[PLUsbCamera.ExposureTime].GetValue();
                    }
                }
                catch (Exception)
                {
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        return camera.Parameters[PLCamera.ExposureTimeRaw].GetValue();
                    }
                    return camera.Parameters[PLUsbCamera.ExposureTime].GetValue();
                }
               
            }

            return 0;
        }
        /// <summary>
        /// 设置增益
        /// </summary>
        /// <param name="Value"></param>
        /// <returns></returns>
        public override double SetGainRaw(double Value)
        {
            if (camera != null)
            {
                try
                {
                    camera.Parameters[PLCamera.GainAuto].TrySetValue(PLCamera.GainAuto.Off);
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        long value;
                        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 + ((((long)Value - min) / incr) * incr);
                        }
                        camera.Parameters[PLCamera.GainRaw].SetValue(value);
                        return camera.Parameters[PLCamera.GainRaw].GetValue();
                    }
                    else
                    {
                        if (Value <= camera.Parameters[PLUsbCamera.Gain].GetMaximum() && Value >= camera.Parameters[PLUsbCamera.Gain].GetMinimum())
                        {
                            camera.Parameters[PLUsbCamera.Gain].SetValue((long)Value);
                        }
                        return camera.Parameters[PLUsbCamera.Gain].GetValue();
                    }
                }
                catch (Exception)
                {
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        return camera.Parameters[PLCamera.GainRaw].GetValue();
                    }
                    return camera.Parameters[PLUsbCamera.Gain].GetValue();
                }
               
            }
            return 0;
        }
        /// <summary>
        /// 设置触发模式
        /// </summary>
        /// <param name="mode"></param>
        public override void SetTriggerMode(TriggerMode mode)
        {
            if (camera != null)
            {
                if (mode==TriggerMode.On)
                {
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        camera.Parameters[PLCamera.AcquisitionMode].SetValue("SingleFrame");
                        camera.Parameters[PLCamera.TriggerSelector].SetValue(PLCamera.TriggerSelector.FrameStart);
                        camera.Parameters[PLCamera.TriggerMode].SetValue(PLCamera.TriggerMode.On);
                    }
                    else
                    {
                        camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart);
                        camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.On);
                    }
                   
                }
                else
                {  
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.AcquisitionStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.AcquisitionStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);

                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);
                            }
                            else
                            {
                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.AcquisitionStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);
                            }
                        }
                    }
                    else
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);

                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);
                            }
                            else
                            {
                                camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart);
                                camera.Parameters[PLCamera.TriggerMode].TrySetValue(PLCamera.TriggerMode.Off);
                            }
                        }
                    }
                   
                }
                //stopWatch.Restart();
            }
        }
        /// <summary>
        /// 设置触发源
        /// </summary>
        /// <param name="source"></param>
        public override void SetTriggerSource(TriggerSource source)
        {
            if (camera != null)
            {
                if (source==TriggerSource.Software)
                {
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.AcquisitionStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Software);
                            }
                            else
                            {                               
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Software);
                            }
                        }
                    }
                    else 
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Software);
                            }
                            else
                            {                               
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Software);
                            }
                        }
                    }
                }
                else
                {
                    if (camera.GetSfncVersion() < Sfnc2_0_0)
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.AcquisitionStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Line1);
                            }
                            else
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Line1);
                            }
                        }
                        camera.Parameters[PLCamera.TriggerDelayAbs].SetValue(5);        // 设置触发延时
                        camera.Parameters[PLCamera.LineSelector].TrySetValue(PLCamera.LineSelector.Line1);
                        camera.Parameters[PLCamera.LineMode].TrySetValue(PLCamera.LineMode.Input);
                        camera.Parameters[PLCamera.LineDebouncerTimeAbs].SetValue(5);       // 设置去抖延时，过滤触发信号干扰

                    }
                    else 
                    {
                        if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameBurstStart))
                        {
                            if (camera.Parameters[PLCamera.TriggerSelector].TrySetValue(PLCamera.TriggerSelector.FrameStart))
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Line1);
                            }
                            else
                            {
                                camera.Parameters[PLCamera.TriggerSource].TrySetValue(PLCamera.TriggerSource.Line1);
                            }
                        }
                        camera.Parameters[PLCamera.TriggerDelay].SetValue(5);// 设置触发延时
                        camera.Parameters[PLCamera.LineSelector].TrySetValue(PLCamera.LineSelector.Line1);
                        camera.Parameters[PLCamera.LineMode].TrySetValue(PLCamera.LineMode.Input);
                        camera.Parameters[PLCamera.LineDebouncerTime].SetValue(5);// 设置去抖延时，过滤触发信号干扰

                    }
                }
                //stopWatch.Restart();
            }
        }
        /// <summary>
        /// 软触发一帧
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        public override bool TriggerSoftware()
        {
            if (camera != null)
            {
                try
                {
                    if (!camera.StreamGrabber.IsGrabbing)
                    {
                        //相机正在采集中
                        camera.Parameters[PLCamera.AcquisitionMode].SetValue(PLCamera.AcquisitionMode.Continuous);
                        camera.StreamGrabber.Start(GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);                      
                    }
                    if ("Off"== camera.Parameters[PLCamera.TriggerMode].GetValue())
                    {
                        SetTriggerMode(TriggerMode.On);
                        SetTriggerSource(TriggerSource.Software);
                    }
                    if (camera.WaitForFrameTriggerReady(1000, TimeoutHandling.ThrowException))
                    {
                        camera.ExecuteSoftwareTrigger();
                        return true;
                    }
                }
                catch
                {
                    return false;
                }
            }
            return false;
        }
        /// <summary>
        /// 设置Gige相机心跳时间
        /// </summary>
        /// <param name="value"></param>
        public void SetHeartBeatTime(long value)
        {
            if (camera != null)
            {
                if (camera.GetSfncVersion() < Sfnc2_0_0)
                {
                    camera.Parameters[PLGigECamera.GevHeartbeatTimeout].SetValue(value);
                }
            }
        }
        /// <summary>
        /// 单张采集
        /// </summary>
        public void Single_Collection() {
            if (camera.StreamGrabber.IsGrabbing)
            {
                return;
            }
            else
            {
                camera.Parameters[PLCamera.AcquisitionMode].SetValue(PLCamera.AcquisitionMode.SingleFrame); 
                camera.StreamGrabber.Start(1, GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
               // stopWatch.Restart();
            }
        }
        //清除图像处理委托事件绑定的方法
        public void Clear_EventProcessImage_Event()
        {
            if (Image_Delegate != null)
            {
                Delegate[] dels = Image_Delegate.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);
                    Image_Delegate -= d as ImageDelegate;
                }
            }
        }
    }

工地搬砖人
关注
  • 5
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
使用c#连接Basler相机，halcon显示采集图像
wei1314520qwe的博客
12-01 1597
本内容提高给初学者小白练习如何连接相机采集，仅供学习使用
Basler相机Sdk采图的演示例程（C#）
soinlove36的专栏
11-06 2953
Basler相机Sdk采图的演示例程
SDK开发思路C#
最新发布
m0_55976972的博客
11-06 927
2.添加引用 如果添加引用报错的话（那么应该是c++文件），所以我们在对应的demo中找到c#语言对应的.cs文件（进行拷贝，复制到我们的程序中）1.拷贝dll库到我们程序的exe同一目录下，若用到halocn算子，则需要将halcon中的相关dll拷贝到exe同一目录下。3.设置回调函数（被动形式） 若颜色采集异常，则可以增加（白平衡，饱和度）处理，调用封装好的借口，显示图像。回调函数：应用程序将函数地址注册给操作系统，并注册事件，当事件产生的时候，操作系统进行调用，并且把数据传上来。
Basler相机SDK开发
苏林同学的博客
01-07 1万+
作为集成商，本着万事从官方开始的原则，先来到basler官网https://www.baslerweb.com/cn/ 随便找一款相机，下载Basler pylon相机软件套装，下载pylon6.0.1相机软件套装(windows版本) 我这里用的是pylon5，一样的，安装的时候注意development装上，gige√上，usb√上 这里安装完软件，把手上的相机接到电脑上，首先要做......
basler相机SDK封装
05-23
basler相机SDK封装，修改了一些简单的功能，可以直接应用。。。。。
BaslerCamera_20191203_基于C#的Basler相机SDK开发示例_读取相机_BaslerCamera_
10-02
在C#中，与Basler相机建立连接是通过调用SDK中的API完成的。首先，我们需要初始化相机设备，并确保其被正确识别。然后，通过SDK提供的接口，我们可以获取相机的详细信息，如型号、分辨率等。 2. **图像采集**： -...
Basler相机连接程序（VS2008）
11-13
Basler相机连接程序是专为使用Visual Studio 2008开发环境设计的，它提供了与德国Basler工业相机交互的代码示例。这个程序的核心功能在于帮助开发者理解和实现相机的连接、图像捕获以及数据显示。Basler相机以其高...
basler相机的C#封装_
12-09
在本项目中，我们关注的是如何使用C#语言对Basler相机进行封装，以便在Windows环境中高效地处理和利用其捕获的图像数据。C#作为Microsoft .NET框架的一部分，提供了丰富的库和工具，使得开发这样的应用变得更为便捷...
basler相机demo
06-25
Basler相机是一款在工业自动化、机器视觉等领域广泛应用的高性能相机。这个"basler相机demo"是基于Qt框架在Visual Studio 2019环境下开发的一个示例程序，它提供了Basler相机的基本操作功能，便于用户进行二次开发。...
C#基于Halcon实现Basler相机采图SDK
09-27
这个对象会连接到网络上的Basler相机，并允许我们设置各种参数，如曝光时间、增益、分辨率等。以下是一个简单的示例代码： ```csharp using Pylon; // 初始化相机 InstantCamera camera = new InstantCamera(Pylon...
Basle相机C#环境下的SDK开发包 C#Demo PylonC.net
03-26
包括了C#环境中的实例代码，其中含有各种相机模式的使用，触发，单帧，连续，多相机等都有具体的代码和注释说明（但都是英文的），对于新手是个很好的参考，Basler相机是工业上应用的比较广泛的一款相机，希望能对学习图形图像的朋友有所帮助。
C# 获取baser工业相机
john_and_jane的博客
05-18 841
C#开发获取并设置baser相机
c#链接basler相机
m0_52364694的博客
05-11 721
【代码】c#链接basler相机。
C#、打开basler相机
星河队长
12-10 5502
使用到了Basler的相机，利用C#编写的SDK，下面进行简单的整理记录。 首先引用basler的动态库文件，具体引用位置如下： 安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll ———————————————— 版权声明：本文为CSDN博主「大_樱_桃」的原创文章，遵循 CC 4.0 BY-S...
【Qt 学习之路】调用工业相机Basler的SDK使用示例
热门推荐
沙师弟专栏
12-19 7万+
由于公司采购的AVT相机不足，需要用Basler相机来弥补，所以我也了解了一下Basler这款相机的SDK。由于Basler这边的相机提供的没有提供Qt的示例，所以我做一个分享出来。本篇的Demo采用的是工业黑白相机。工业应用中，如果我们要处理的是与图像颜色有关，那么我们最好采用彩色工业相机；如果不是，那么我们最好选用黑白工业相机，因为在同样分辨率下的工业相机，黑白工业教学精度比彩色工业相机高，尤其是在看图像边缘的时候，黑白工业相机的效果更好。
VS(C#)调用Basler相机SDK采集图像及基本功能设定
大樱桃的博客
08-08 2万+
使用到了Basler的相机，利用C#编写的SDK，下面进行简单的整理记录。 首先引用basler的动态库文件，具体引用位置如下： 安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll 引用命名空间 using Basler.Pylon; using System; using System.Col...
连接Basler相机Demo(C#版)
Major_S的博客
08-13 2034
using System; //using System.Collections.Generic; using System.Linq; //using System.Text; //using System.Threading.Tasks; using Basler.Pylon; //using System; using System.Drawing; using System.Drawing.Imaging; namespace BaslerDemo { class BalserCam
巴斯勒相机基于SDK 二次开发C++程序
09-15 1201
巴斯勒相机在VS中如何进行连接调用呢（软触发调用）2.调用巴斯勒相机提供的接口，连接巴斯勒相机；其他引用第三方库以及对应头文件。1.查找巴斯勒相机网口；（安装巴斯勒相机软件）
c#调用basler相机sdk
07-03
"C" 是英文字母表中的第三个字母。它是一个常见的字母，用于构建英语的单词和语句。在汉语拼音中，"C" 表示的是声母 "ch" 的发音。 在计算机科学中，"C" 是一种编程语言，它由Dennis Ritchie在20世纪70年代开发。C语言是一种高级编程语言，被广泛应用于系统开发、嵌入式系统和其他需要高效性能和控制权的应用程序。它是许多其他编程语言的基础，例如C++和Java。 此外，"C" 也可以表示摄氏度的单位。摄氏度是一种温度度量单位，以开氏温标为基础，将水的冰点和沸点分别设定为0°C和100°C。摄氏度常用于描述气温和室温。 在化学中，"C" 是碳元素的化学符号。碳是地球上最常见的元素之一，它具有许多重要的化学性质和应用。碳是有机化合物的基础，它在生物学、化学和材料科学中发挥着重要作用。 总而言之，"C" 是一个多功能的字母，在不同领域中扮演着不同的角色。无论是作为一个字母、一个编程语言、一个温度单位或一个化学元素，它都具有广泛的应用和重要性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值