精华内容
下载资源
问答
  • C#、打开basler相机

    千次阅读 2019-12-10 09:46:27
    使用到了Basler相机,利用C#编写的SDK,下面进行简单的整理记录。 首先引用basler的动态库文件,具体引用位置如下: 安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll ————...

    使用到了Basler的相机,利用C#编写的SDK,下面进行简单的整理记录。
    首先引用basler的动态库文件,具体引用位置如下:
    安装目录\Basler\pylon 5\Development\Assemblies\Basler.Pylon\x64\Basler.Pylon.dll
    ————————————————
    版权声明:本文为CSDN博主「大_樱_桃」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/biggestcherry/article/details/98884073

    using System;

    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using HalconDotNet;
    using Basler.Pylon;
    using System.Runtime.InteropServices;
    
    namespace BaslerSDK
    {
        class BaslerClass
        {
            List<ICameraInfo> allCameras = null;//创建ICameraInfo对象的列表,用于保存遍历到的所有相机信息
            Camera myCamera = null;//创建相机对象
            HImage image = null;
            
            public BaslerClass(string sn)
            {
            }
    
            public int connectCamera(string id)//连接相机,返回-1为失败,0为成功
            {
                string m_SerialNumber = "";//接收设备返回的序列号
                allCameras = CameraFinder.Enumerate();//获取所有相机设备
                for (int i = 0; i < allCameras.Count; i++)
                {
                    try
                    {
                        if (allCameras[i][CameraInfoKey.SerialNumber] == id)
                        {
                            //如果当前相机信息中序列号是指定的序列号,则实例化相机类
                            myCamera = new Camera(allCameras[i]);
                            myCamera.Open();//打开相机
                            return 0;
                        }
                        continue;
                    }
                    catch
                    {
                        return -1;
                    }
                }
                return -1;
            }
            
            public int startCamera()//相机开始采集,返回-1为失败,0为成功
            {
                try
                {
                    myCamera.StreamGrabber.Start();
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public int stopCamera()//停止相机采集,返回-1为失败,1为成功
            {
                try
                {
                    myCamera.StreamGrabber.Stop();
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public int closeCamera()//关闭相机,返回-1为失败,1为成功
            {
                try
                {
                    myCamera.Close();
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public int softTrigger()//发送软触发命令
            {
                try
                {
                    myCamera.ExecuteSoftwareTrigger();
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public HImage ReadBuffer()//读取相机buffer并生成HImage格式的图像
            {
                IGrabResult grabResult = myCamera.StreamGrabber.RetrieveResult(4000, TimeoutHandling.ThrowException);//读取buffer,超时时间为4000ms
                image = new HImage();
                using (grabResult)
                {
                    if (grabResult.GrabSucceeded)
                    {
                        if (IsMonoData(grabResult))
                        {
                            //如果是黑白图像,则利用GenImage1算子生成黑白图像
                            byte[] buffer = grabResult.PixelData as byte[];
                            IntPtr p = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
                            image.GenImage1("byte", grabResult.Width, grabResult.Height, p);
                        }
                        else
                        {
                            if (grabResult.PixelTypeValue != PixelType.RGB8packed)
                            {
                                //如果图像不是RGB8格式,则将图像转换为RGB8,然后生成彩色图像
                                //因为GenImageInterleaved算子能够生成的图像的数据,常见的格式只有RGB8
                                //如果采集的图像是RGB8则不需转换,具体生成图像方法请自行测试编写。
                                byte[] buffer_rgb = new byte[grabResult.Width * grabResult.Height * 3];
                                Basler.Pylon.PixelDataConverter convert = new PixelDataConverter();
                                convert.OutputPixelFormat = PixelType.RGB8packed;
                                convert.Convert(buffer_rgb, grabResult);
                                IntPtr p = Marshal.UnsafeAddrOfPinnedArrayElement(buffer_rgb, 0);
                                image.GenImageInterleaved(p, "rgb", grabResult.Width, grabResult.Height, 0, "byte", grabResult.Width, grabResult.Height, 0, 0, -1, 0);
                            }
                        }
                        return image;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            
            public int setExposureTime(longExposureTimeNum)//设置曝光时间us
            {
                try
                {
                    myCamera.Parameters[PLCamera.ExposureTimeAbs].SetValue(ExposureTimeNum);
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
    
            public int pixelFormat(uint pixelType)//设置图像格式
            {
                //1:Mono8 2:彩色YUV422
                try
                {
                    if (pixelType == 1)
                    {
                        myCamera.Parameters[PLCamera.PixelFormat].TrySetValue(PLCamera.PixelFormat.Mono8);
                    }
                    else if(pixelType == 2)
                    {
                        myCamera.Parameters[PLCamera.PixelFormat].TrySetValue(PLCamera.PixelFormat.YUV422Packed);
                    }
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public int setHeight(longheight)//设置图像高度
            {
                try
                {
                    if (myCamera.Parameters[PLCamera.Height].TrySetValue()height))
                        return 0;
                    else
                        return  -1;
                }
                catch
                {
                    return -1;
                }
            }
            
            public int setWidth(longwidth)//设置图像宽度
            {
                try
                {
                    if (myCamera.Parameters[PLCamera.Width].TrySetValue(width))
                        return 0;
                    else
                        return -1;
                }
                catch
                {
                    return -1;
                }
            }
            
            public int setOffsetX(longoffsetX)//设置图像水平偏移
            {
                try
                {
                    if (myCamera.Parameters[PLCamera.OffsetX].TrySetValue(offsetX))
                        return 0;
                    else
                        return -1;
                }
                catch
                {
                    return -1;
                }
            }
            
            public int setOffsetY(longoffsetY)//设置图像竖直偏移
            {
                try
                {
                    if (myCamera.Parameters[PLCamera.OffsetY].TrySetValue(offsetY))
                        return 0;
                    else
                        return -1;
                }
                catch
                {
                    return -1;
                }
            }
        
            public int setTriggerMode(uint TriggerModeNum)//设置触发模式
            {
                //1:为On 触发模式
                //0:Off 触发模式
                try
                {
                    if (myCamera.Parameters[PLCamera.TriggerMode].TrySetValue(TriggerModeNum==1?"On":"Off"))
                        return 0;
                    else
                        return -1;
                }
                catch
                {
                    return -1;
                }
            }
            
            public int closeBalanceAuto()//关闭自动白平衡
            {
                try
                {
                    myCamera.Parameters[PLCamera.BalanceWhiteAuto].TrySetValue("Off");
                }
                catch
                {
                    return -1;
                }
                return 0;
            }
            
            public int setTriggerSource(uint TriggerSourceNum)//设置触发源
            {
                //直接改为软触发,此处已经写死
                try
                {
                    if (myCamera.Parameters[PLCamera.TriggerSource].TrySetValue("Software"))
                        return 0;
                    else
                        return -1;
                }
                catch
                {
                    return -1;
                }
            }
            
             private Boolean IsMonoData(IGrabResult iGrabResult)//判断图像是否为黑白格式
            {
                switch (iGrabResult.PixelTypeValue)
                {
                    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;
                }
            }
         }
     }
    

    SDK调用方法:
    BaslerSDK camera = new BaslerSDKcamera ();//创建相机对象并实例化
    camera.connectCamera(“123456”);//连接相机,传入相机序列号123456
    camera.startCamera();//开启相机采集
    camera.setExposureTime(10000);//设置曝光时间为10ms
    camera.softTrigger();//发送软触发采集图像
    Himage image=camera.readImage();//获取采集到且转换后的图像
    camera.stopCamera();//停止相机采集
    ————————————————
    版权声明:本文为CSDN博主「大_樱_桃」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/biggestcherry/article/details/98884073

    展开全文
  • 使用环境OpenCV3.0+VS2013,配置Basler工业相机程序。
  • 有没有大神搞过basler工业相机,为什么用opencv搞出来是一条条的乱线条
  • 为了对basler相机进行参数设置,例如曝光时间调节、ip设置 官网 2.基于python的basler相机获取图像 2.1pylon安装并导入 1).下载pypylon(下载地址) 2).在下载好的文件夹中,打开终端并source activate到要安装的...

    1.Pylon Viewer 设置

    为什么要安装Pylon Viewer ?
    为了对basler相机进行参数设置,例如曝光时间调节、ip设置
    官网

    2.基于python的basler相机获取图像

    2.1pylon安装并导入

    1).下载pypylon(下载地址
    2).在下载好的文件夹中,打开终端并source activate到要安装的虚拟环境里,使用pip install ***。
    注:如果 1.7.2版本安装后,不能使用,尝试安装低版本的(例如1.6.0)
    导入代码

    from pypylon import pylon
    

    2.2 查找相机函数

    def search_get_device():
        tl_factory = pylon.TlFactory.GetInstance()
        for dev_info in tl_factory.EnumerateDevices():
            print("DeviceClass:", dev_info.GetDeviceClass())
            if dev_info.GetDeviceClass() == 'BaslerGigE':  # 千兆网(GigE)
                print(f"ModelName:{dev_info.GetModelName()}\n"f"IP:{dev_info.GetIpAddress()}")
                camera = pylon.InstantCamera(tl_factory.CreateDevice(dev_info))
                break
        else:
            raise EnvironmentError("no GigE device found")
        return camera
    

    2.3获取相机图像

    cam = search_get_device()  #查找相机
    cam.Open()  #将相机打开
    #以最小延迟连续抓取(视频)
    cam.StartGrabbing(pylon.GrabStrategy_LatestImageOnly)
    converter = pylon.ImageFormatConverter()
    #转换为opencv BGR格式
    converter.OutputPixelFormat = pylon.PixelType_BGR8packed   # 如果需要转换成RBG格式,改为PixelType_RBG8packed
    converter.OutputBitAlignment = pylon.OutputBitAlignment_MsbAligned
    #等待一个图像,然后检索它。超时时间为5000ms。
    grabResult = cam.RetrieveResult(5000, pylon.TimeoutHandling_ThrowException)
    # 如果图片获取成功
    if grabResult.GrabSucceeded():
    	#获取图片的高、宽
    	print("SizeX: ", grabResult.Width)
        print("SizeY: ", grabResult.Height)
        #将图片转成class 'numpy.ndarray',shape 1944*2592*2(具体的高宽要根据自己对相机参数的设置)
        img = grabResult.Array
        #后转换为图像(ndarray)形状1944*2592*3
        image = converter.Convert(grabResult)
        weld_img = image.GetArray()
    

    更加详细的代码请查阅参考链接3

    可参考:
    1.Basler ace 相机软件设置、 硬件连接、软件触发,c++语言,程序硬件触发全套详细资料
    2.pylon Viewer 使用说明(Windows下)
    3.Basler 工业相机 Python开发采集数据、保存照片

    展开全文
  • 关于basler网口相机,最近使用的过程中出现了一些小的问题,关于丢帧的和捕捉错误的现象做如下总结 正文: 1、相机丢帧主要是先确定自己使用的电脑的网卡,如果使用千兆网口的相机,那么网口对应的也必须是千兆...

    关于basler网口相机,最近使用的过程中出现了一些小的问题,关于丢帧的和捕捉错误的现象做如下总结

    正文:

    1、相机丢帧主要是先确定自己使用的电脑的网卡,如果使用千兆网口的相机,那么网口对应的也必须是千兆网口。检查一下

     

    2、打开Pylon,在其中找到Packet Size

    如图:

     这个Packet Size调到最大,看看还是否丢帧;

    3、如果做了上面的2,还是有丢帧现象,打开“网络设置”,在里面把巨型帧打开,全双工打开。

     

     

    4、最后,由于现在的设置本次相机下电后会变掉,所以要设置成上电就应用本设置,这是Pylon的用户定义功能

     

    完!

     

    展开全文
  • Basler相机

    2021-07-09 13:53:33
    Basler相机 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; ...

    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);
                }
            }
    
        }
    }
    
    
    展开全文
  • basler相机封装接口

    2019-02-26 22:28:48
    basler相机参数设置、打开相机、采集代码。对相机的操作进行封装!简单好用!
  • (1)在相机工作空间catkin_basler目录下打开终端,输入命令 source ~/catkin_basler/devel/setup.bash roslaunch pylon_camera pylon_camera_node.launch 二、激光雷达打开 (1)配置IP地址,并连接好设备,打开...
  • 简单使用gige千兆网口basler工业相机

    千次阅读 2020-05-17 10:18:55
    1,安装basler相机的驱动程序,选择安装pylonc.net 2,创建c#程序,项目添加引用pylonc.net.dll动态库 3,最简单使用gige千兆网口basler工业相机 a,using PylonC.NET; b,//声明basler相机变量 PYLON_DEVICE_...
  • basler相机mfc控制

    2018-05-30 18:08:17
    使用mfc开发的basler相机控制代码,可以实现对basler网络相机的链接,打开,设置简单参数的功能
  • basler相机demo

    2021-06-25 11:11:27
    qt在vs2019下开发的demo,源码为basler中国东北区技术提供。有打开采集关闭基本功能。方便二次开发
  • 基于MFC的Basler工业相机SDK开发

    千次阅读 2020-02-12 16:08:12
    下载安装pylon,到basler官方网站下载适合自己相机的pylon版本(我的是pylon 5.0),安装的时候注意选择安装开发者模式(开发者模式才含有SDK)。搜索相机IP并改成固定IP,使系统和相机利用路由器连接在同一个局域网...
  • basler工业相机使用经验小记

    万次阅读 2018-05-22 20:15:47
    1,windows10的系统,要用5以上的sdk不然打不开相机。 2,如果用opencv或vs程序打开忘记没有关,则下次会找不开,这时可以通过禁用和启用调好。 如果打开后连不上,并且后找不到如上图所示的本地...
  • Qt(C++)项目中使用 Basler 工业相机(1 枚举相机)最近的一个项目中用到Basler 的GigE 接口的工业相机。为此花了好几天时间研究了pylon 的用法。本文就是学习过程中做的笔记。Pylon 的结构可以参考下图。 图 1 ...
  • Halcon连接相机采集图像(Basler相机)

    千次阅读 2020-01-06 17:44:02
    4,打开basler相机的IPConfigurator,如下图配置,这里配置的IP与上面填写的IP需在同一网段 配置点Ok后state显示ok说明相机配置成功,现在可以正常使用相机了 5,打开Halcon软件,助手-》Image Aquisition 01 ...
  • 本帖旨在記錄一下在Ubuntu16.04下配置basler工業相機pylon sdk,以及結合opencv進行CMake配置使用的一些事項。 1.Prerequisite ubuntu16.04 + Basler工業相機 + pylon5 sdk 給個傳送門:Pylon下載 2.pylon的...
  • Basler相机SDK开发

    千次阅读 多人点赞 2020-01-07 17:59:42
    随便找一款相机,下载Basler pylon相机软件套装,下载pylon6.0.1相机软件套装(windows版本) 我这里用的是pylon5,一样的,安装的时候注意development装上,gige√上,usb√上 这里安装完软件,把手上的相机...
  • Qt(C++)项目中使用 Basler 工业相机(2 参数设置)上一篇博客介绍了 pylon 的基本结构和如何枚举系统中的相机。这一篇主要讲讲如何设置相机的各个参数。在设置相机参数之前,先要获取相机对象。Pylon::CTlFactory ...
  • 解压Basler相机的驱动压缩包pylon_6.1.1.19861_x86_64_setup.tar.gz,解压之后有一个INSTALL文件和一个压缩包pylon_6.1.1.19861_x86_64.tar.gz。 2. 解压安装包里面的压缩包到指定的路径下 在computer->...
  • 用Matlab控制basler工业相机(USB3.0接口)

    千次阅读 2020-11-08 23:00:56
    一.准备工作 1.Matlab以及Image ...4.basler USB3.0接口相机 以下内容中用到的软硬件版本为: 1.Matlab R2020b以及Image Acquisition 6.3(R2020b) 2.Basler pylon 6.1.1 3.Basler acA2040-90uc工业相机 二.安装B
  • Basler工业相机基于opencv 采集图像

    千次阅读 2017-02-10 11:52:21
    本实验在两个博客的基础上实现的,首先是配置opencv   ...,但结果都失败了,最终自己的一些... 然后是配置Basler相机的SDK:http://blog.csdn.net/u013351270/article/details/54345855 继续学习中...
  • 做法是先在linux下通过pylon软件将相机打开,然后再在Ros下打开相机。 一、在Linux操作系统中安装Pylon软件 (1)打开basler的官网,在官网上进行下载安装包https://www.baslerweb.com/en/products/software/ 搜索...
  • 使用的是basler aca2500-14gm相机,分辨率是2592*1944,但是在opencv打开双摄像头时,只能打开一个摄像头,另一个打不开; 使用basler自带sdk,Grab_MultipleCameras.cpp又是打开了摄像头但是两幅窗口都是灰色; ...
  • Basler相机常见问题

    千次阅读 2020-01-16 11:52:43
    当出现这个问题时,打开basler pylonview,打开相机时会出现下图的报错信息。 如果调试或者运行pylon SDK的编写的程序,报错信息如下图所示 2.原因 千兆网视觉协议的标准是通过心跳的这种方式来监测相机和网卡的连接...
  • Basler相机获取与设置相机图片格式列表 1、获取所有的图片格式列表 2、从图片格式列表中选择一种图片格式进行设置图片格式
  • 安装basler的驱动,我安装的是pylon5 选择developer的版本 接下来配置一下vs的属性表 1、首先是C/C++ -> 附加库目录 ->编辑:$(PYLON_DEV_DIR)\include 2、之后是 链接器-> 附加库目录 ->编辑:...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 331
精华内容 132
关键字:

basler打开相机