Basler相机

最新推荐文章于 2024-08-08 20:23:02 发布
最新推荐文章于 2024-08-08 20:23:02 发布
阅读量655 收藏 4
点赞数
文章标签： c# windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/118605170
版权
这篇博客介绍了如何使用C# SDK操作Basler相机，包括设置相机参数如曝光时间和触发源，以及启动和停止图像采集。通过事件处理程序处理图像抓取，并进行图像处理。此外，还展示了如何开启和关闭相机，以及在不同场景下调整相机参数。
摘要由CSDN通过智能技术生成

Basler相机

设置相机参数

public bool SetCameraParam(string ParamType, string ParamValue)
{
    try
    {
        switch (ParamType)
        {
            case "ExposureTimeAbs":
                {
                    if (!camera.Parameters[PLCamera.ExposureTimeAbs].TrySetValue(double.Parse(ParamValue)))
                    {
                        return false;
                    }
                }
                break;
            case "TriggerSource":
                {
                    if (!camera.Parameters[PLCamera.TriggerSource].TrySetValue(ParamValue))
                    {
                        return false;
                    }
                }
                break;
            default:
                break;
        }
        return true;
    }
    catch (Exception e)
    {
        // MessageBox.Show(e.ToString());
        MachineMaster.tsk.UpdateLog(e.ToString());

        return false;
    }
}

关闭相机

public void DestroyCamera()
{
    if (camera != null)
    {
        camera.Close();
        camera.Dispose();
        camera = null;
    }
}

连接Basler相机Demo(C#版)

camera.StreamGrabber.GrabStarted += StreamGrabber_GrabStarted;
camera.StreamGrabber.ImageGrabbed += StreamGrabber_ImageGrabbed;
camera.StreamGrabber.GrabStopped += StreamGrabber_GrabStopped;

Basler SDK pylon6使用C#采集图像实例

连接相机

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Basler.Pylon;
using System.Windows.Forms;
using System.Drawing;
using System.IO;
using System.Diagnostics;
using System.Threading;
using HalconDotNet;

namespace Lead
{
    public class Basler_SDK_Mono
    {
        public Camera camera;
        public Bitmap bitmap;
        public Bitmap CopyBitmap;
        private int CameraIndex;

        public bool GrabFlag = false;

        // Basler.Pylon.PixelDataConverter _conveter;
        AutoResetEvent _resetEvent = new AutoResetEvent(true);
        public Basler_SDK_Mono(string CameraSN, int Camera_Index)
        {
            try
            {
                camera = new Camera(CameraSN);
                this.CameraIndex = Camera_Index;
            }
            catch
            {

            }
        }

        //打开相机
        public bool OpenCamera()
        {
            try
            {
                if (!camera.IsOpen)
                {
                    camera.Open();
                    camera.StreamGrabber.ImageGrabbed += OnImageGrabbed;
                    camera.Parameters[PLCamera.TriggerSelector].TrySetValue("FrameStart");
                    camera.Parameters[PLCamera.TriggerMode].TrySetValue("On");
                    camera.Parameters[PLCamera.TriggerSource].TrySetValue("Software");
                    camera.Parameters[PLCamera.TriggerActivation].TrySetValue("Falling Edge");
                    //camera.Parameters[PLCamera.FrameTimeoutAbs].TrySetValue(20000);
                    camera.StreamGrabber.Start(GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
                    BitmapFactory.CreateBitmap(out bitmap, (int)camera.Parameters[PLCamera.Width].GetValue(), (int)camera.Parameters[PLCamera.Height].GetValue(), false);
                    //switch (CameraIndex)
                    //{
                    //    case 1:
                    //        {
                    //            SetCameraParam("ExposureTimeAbs", "600");
                    //        }
                    //        break;
                    //    case 2:
                    //        {
                    //            SetCameraParam("ExposureTimeAbs", "600");
                    //        }
                    //        break;
                    //    case 3:
                    //        {
                    //            SetCameraParam("ExposureTimeAbs", "600");
                    //        }
                    //        break;
                    //    default:
                    //        break;
                    //}
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        //开始采集
        public bool StartStream()
        {
            try
            {
                if (camera.IsOpen)
                {
                    camera.StreamGrabber.Start(GrabStrategy.LatestImages, GrabLoop.ProvidedByStreamGrabber);
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        public bool StopStream()
        {
            try
            {
                if (camera.StreamGrabber.IsGrabbing)
                {
                    camera.StreamGrabber.Stop(); 
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        //抓取图像
        //object LockObj = new object();
        private void OnImageGrabbed(Object sender, ImageGrabbedEventArgs e)
        {
            try
            {
                IGrabResult grabResult = e.GrabResult;
                long ImageNo = grabResult.ImageNumber;
                if (grabResult.GrabSucceeded)
                {
                    Debug.WriteLine(grabResult.ImageNumber);
                    byte[] buffer = grabResult.PixelData as byte[];
                    BitmapFactory.UpdateBitmap(bitmap, buffer, grabResult.Width, grabResult.Height, false);
                    CopyBitmap = (Bitmap)bitmap.Clone();
                    打开图像处理线程
                    //Task RunToolBlock_1 = new Task(() => MachineMaster.Camera1_Run());
                    //Task RunToolBlock_2 = new Task(() => MachineMaster.Camera2_Run());
                    //Task RunToolBlock_3 = new Task(() => MachineMaster.Camera3_Run());
                    switch (CameraIndex)
                    {
                        case 1:
                            //离线存图
                            MachineMaster.halcon.ho_ShowImage1 = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap);
                            {
                                switch (MachineMaster.strBGside+MachineMaster.strLightNo)
                                {
                                    case "S1":
                                        if (MachineMaster.AutoRunEnable_Camera1 && MachineMaster.AutoRunFlag_Camera1)
                                        {
                                            ImageInfo ImageInfo = new ImageInfo() { Image = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), Index = ImageNo };
                                            if (MachineMaster.LstImage_1.Find(x => x.Index == ImageNo) == null)
                                            {
                                                MachineMaster.LstImage_1.Add(ImageInfo);
                                            }
                                            new Action(() =>
                                            {
                                                MachineMaster.VImageProcess_1_1(MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), ImageNo);
                                            }).BeginInvoke(null, null);
                                        }
                                        break;
                                    case "S2":
                                        if (MachineMaster.AutoRunEnable_Camera1 && MachineMaster.AutoRunFlag_Camera1)
                                        {
                                            ImageInfo ImageInfo = new ImageInfo() { Image = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), Index = ImageNo };
                                            if (MachineMaster.LstImage_1.Find(x => x.Index == ImageNo) == null)
                                            {
                                                MachineMaster.LstImage_1.Add(ImageInfo);
                                            }
                                            new Action(() =>
                                            {
                                                MachineMaster.VImageProcess_1_2(MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), ImageNo);
                                            }).BeginInvoke(null, null);
                                        }
                                        break;
                                    case "S1;2":
                                        if (MachineMaster.AutoRunEnable_Camera1 && MachineMaster.AutoRunFlag_Camera1)
                                        {
                                            ImageInfo ImageInfo = new ImageInfo() { Image = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), Index = ImageNo };
                                            if (MachineMaster.LstImage_1.Find(x => x.Index == ImageNo) == null)
                                            {
                                                MachineMaster.LstImage_1.Add(ImageInfo);
                                            }
                                            new Action(() =>
                                            {
                                                //MachineMaster.VImageProcess_1_12(MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), ImageNo);
                                            }).BeginInvoke(null, null);
                                        }
                                        break;
                                    default:
                                        break;
                                }                           
                            }
                            break;
                        case 2:
                            {
                                MachineMaster.halcon.ho_ShowImage2 = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap);
                                switch (MachineMaster.strLightNo)
                                {
                                    case "1":
                                        if (MachineMaster.AutoRunEnable_Camera2 && MachineMaster.AutoRunFlag_Camera2)
                                        {
                                            ImageInfo ImageInfo = new ImageInfo() { Image = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), Index = ImageNo };
                                            if (MachineMaster.LstImage_1.Find(x => x.Index == ImageNo) == null)
                                            {
                                                MachineMaster.LstImage_1.Add(ImageInfo);
                                            }
                                            new Action(() =>
                                            {
                                               // MachineMaster.ImageProcess_2_1(MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), ImageNo);
                                            }).BeginInvoke(null, null);
                                        }
                                        break;
                                    case "2":
                                        if (MachineMaster.AutoRunEnable_Camera2 && MachineMaster.AutoRunFlag_Camera2)
                                        {
                                            ImageInfo ImageInfo = new ImageInfo() { Image = MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), Index = ImageNo };
                                            if (MachineMaster.LstImage_1.Find(x => x.Index == ImageNo) == null)
                                            {
                                                MachineMaster.LstImage_1.Add(ImageInfo);
                                            }
                                            new Action(() =>
                                            {
                                                //MachineMaster.ImageProcess_2_2(MachineMaster.halcon.HImageConvertFromBitmap8(CopyBitmap), ImageNo);
                                            }).BeginInvoke(null, null);
                                        }
                                        break;
                                    default:
                                        break;
                                    }
                                }
                            break;
                    }

                    GrabFlag = true;
                    _resetEvent.Set();
                }
                else
                {
                    //MessageBox.Show("grabResult.NoGrabSucceeded");
                    _resetEvent.Set();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        public bool StartGrab()
        {
            try
            {
                if (camera == null)
                {
                    return false;
                }

                if (!camera.IsOpen)
                {
                    return false;
                }

                int index = 1;
                while (true)
                {
                    if (index == 10)
                    {
                        throw new Exception("Fail to WaitForFrameTriggerReady!");
                    }
                    if (false == camera.WaitForFrameTriggerReady(100, TimeoutHandling.Return))
                    {
                        index++;
                        Thread.Sleep(50);
                        continue;
                    }
                    _resetEvent.Reset();
                    camera.ExecuteSoftwareTrigger();
                    _resetEvent.WaitOne();
                    break;
                }


                //if (camera.WaitForFrameTriggerReady(100, TimeoutHandling.ThrowException))
                //{
                //    _resetEvent.Reset();
                //    camera.ExecuteSoftwareTrigger();
                //    _resetEvent.WaitOne();
                //}
                if (!GrabFlag)
                {
                    Thread.Sleep(300);
                    index = 1;
                    while (true)
                    {
                        if (index == 10)
                        {
                            throw new Exception("Fail to WaitForFrameTriggerReady!");
                        }
                        if (!camera.WaitForFrameTriggerReady(1000, TimeoutHandling.Return))
                        {
                            index++;
                            Thread.Sleep(50);
                            continue;
                        }
                        _resetEvent.Reset();
                        camera.ExecuteSoftwareTrigger();
                        _resetEvent.WaitOne();
                        break;
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
        }


        public bool SetCameraParam(string ParamType, string ParamValue)
        {
            try
            {
                switch (ParamType)
                {
                    case "ExposureTimeAbs":
                        {
                            if (!camera.Parameters[PLCamera.ExposureTimeAbs].TrySetValue(double.Parse(ParamValue)))
                            {
                                return false;
                            }
                        }
                        break;
                    case "TriggerSource":
                        {
                            if (!camera.Parameters[PLCamera.TriggerSource].TrySetValue(ParamValue))
                            {
                                return false;
                            }
                        }
                        break;
                    default:
                        break;
                }
                return true;
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString());
                return false;
            }
        }

        //关闭相机
        public void CloseCamera()
        {
            try
            {
                if (camera == null)
                    return;

                //if (camera.StreamGrabber.IsGrabbing)
                //{
                //    camera.StreamGrabber.Stop();
                //}


                if (camera.IsOpen)
                {
                    camera.Close();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }

    }
}
*Major*
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
basler相机demo
04-15
运行环境为Qtcreator,下载pylon，完成development安装后，更改pro文件里面包含和库路径，完成后直接嘛运行，能恋情曝光时间和增益控制相机
Basler工业相机SDK sample
08-01
资源中是官网的Basler工业相机二次开发的SDK，内有c,c++,c#三个版本
多个Basler相机调试采集Demo
03-18
一个控制台服务，项目Demo主要是引用了Basler的驱动开发连接多个相机，并且设置了参数配置，连接监控，以及断线处理等。
连接Basler相机Demo(C#版)
Major_S的博客
08-13 2083
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
basler相机连续采集
10-01
Basler相机是一款在工业自动化、科研等领域广泛应用的高性能数字相机，以其卓越的图像质量和稳定的性能著称。"Basler相机连续采集"指的是利用特定的软件或编程方式，使得Basler相机能够持续不断地捕获和记录图像，这...
basler相机手册
05-08
在使用Basler相机之前，请确保阅读并理解所有相关的使用条款。这些条款通常包括但不限于产品的保修政策、使用限制以及安全指南等内容。 **2. 预防措施** 为了确保Basler ToF相机的安全使用和延长使用寿命，需要遵循...
basler相机读取
12-18
Basler相机是一款在工业自动化、机器视觉等领域广泛应用的高性能数字相机。它以其高分辨率、高速度和稳定性著称。在本教程中，我们将探讨如何利用Visual Studio（VS）集成开发环境和OpenCV库来读取并处理来自Basler...
basler相机的示例
04-10
basler相机的示例，该文件包括了basler相机的C++示例。是相机自带的demo
巴斯勒相机开发的双相机Demo
04-26
基于CSharpz巴斯勒相机开发的多相机Demo，很适合新人使用。。。。。。
basler相机的MFC框架demo
04-13
配置好环境后，程序能完美运行，可以单排，实时显示，存储。可以调相机的曝光时间和增益，可以看到几个相机的名称（如果连了大于一个的相机）
C#开发巴斯勒相机SDK
01-10
简单的做了一个C#开发巴斯勒SDK，主要就是单次取图，实时拍摄，参数设置，图像比例设置等
【Qt 学习之路】调用工业相机Basler的SDK使用示例
热门推荐
沙师弟专栏
12-19 7万+
由于公司采购的AVT相机不足，需要用Basler相机来弥补，所以我也了解了一下Basler这款相机的SDK。由于Basler这边的相机提供的没有提供Qt的示例，所以我做一个分享出来。本篇的Demo采用的是工业黑白相机。工业应用中，如果我们要处理的是与图像颜色有关，那么我们最好采用彩色工业相机；如果不是，那么我们最好选用黑白工业相机，因为在同样分辨率下的工业相机，黑白工业教学精度比彩色工业相机高，尤其是在看图像边缘的时候，黑白工业相机的效果更好。
MIL开发实践(3)——MIL触发采图
zwz_chome的博客
11-20 3069
接下来就要完成触发采图了，这个触发采图耗费的时间比上面那个要长多了，主要原因还是在于对使用的函数理解不够深刻，后面听我细细道来。 首先，我们最主要使用的是这个回调函数， MdigHookFunction(MilDigitizer, M_GRAB_FRAME_START, ProcessingFunction, &UserHookData); 这个函数会再程序有采图操作的时候 ...
basler相机的类
weixin_44840658的博客
04-13 3655
1、DeviceRemovalHandling CTlFactory类用于创建通用传输 CInstantCamera类用于使用找到的第一个相机设备创建即时相机对象。 CHeartbeatHelper类用于将心跳超时设置为适当的值。 CSampleConfigurationEventHandler用于处理设备删除事件。 2、Grab CInstantCamera类用于使用找到的第一个相机设备创建即时...
Basler ace 相机软件设置、 硬件连接、软件触发，程序硬件触发全套详细资料
努力努力努力
10-11 1万+
一、触发使用说明书 https://wenku.baidu.com/view/4a9fe5e4f78a6529657d5356.html?fr=search-1 二、BASLAR相机触发说明PPT课件 https://wenku.baidu.com/view/dcc580e579563c1ec4da7168.html 三、BASLAR相机软件套装下载 https://www.baslerweb.com/cn/sales-support/downloads/software-downloads/py
C#、打开basler相机
星河队长
12-10 5602
使用到了Basler的相机，利用C#编写的SDK，下面进行简单的整理记录。 首先引用basler的动态库文件，具体引用位置如下： 安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll ———————————————— 版权声明：本文为CSDN博主「大_樱_桃」的原创文章，遵循 CC 4.0 BY-S...
项目总结之Basler相机的调用
wyx1455249921的博客
03-18 3975
项目要求一个后台服务，通过交换机连接并监控多个Basler相机
C#学习总结
最新发布
weixin_43284350的博客
08-08 1206
用追马的时间种草吧
Basler相机SDK API接口详解
"Basler相机的API说明文档详细介绍了Basler相机的PYLON SDK，提供了C/C++/C#的API接口和函数说明。该文档适用于软件版本5.x，涵盖了多种示例代码，包括设备移除处理、图像抓取、相机事件、Chunk图像、多播、多摄像头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值