相机通用类之海康相机，软触发硬触发（飞拍），并输出halcon格式对象

已于 2023-11-14 17:41:09 修改
阅读量5.9k 收藏 47
点赞数 10
分类专栏： 工业相机 上位机 文章标签： c# 机器人
于 2023-11-14 17:36:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51559565/article/details/132663442
版权 
//在此之前可以先浏览我编写的通用上位机类，更方便理解
https://blog.csdn.net/m0_51559565/article/details/134403745

最近完成一个关于海康采图的demo，记录并说明用法。
先上代码。

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Threading;
using MvCamCtrl.NET;
using HalconDotNet;
using System.Windows.Forms;
using WeldingInspection.MyCamer;

namespace WeldingInspection
{
    public partial class HKCamerSDK: MyBaseCamera
    {
        //创建相机集合，用于存放相机
        MyCamera.MV_CC_DEVICE_INFO_LIST m_pDeviceList;
        MyCamera.MV_CC_DEVICE_INFO device;
        MyCamera HKMyCamera = new MyCamera();
        MyCamera.cbOutputExdelegate ImageCallback;
        MyCamera.cbExceptiondelegate pCallBackFunc;
        HObject hPylonImage = new HObject();

        /// <summary>
        /// 查找并开启相机
        /// </summary>
        /// <param name="CamerNum">开启第几个相机</param>
        /// <returns>开启成功返回true，开启失败返回false，并在输出打印错误码</returns>
        public override List<string> FindCamer()
        {
            int nRet;
            List<string> CamerName = new List<string>();
            // ch:创建设备列表 en:Create Device List
            System.GC.Collect();

            nRet = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref m_pDeviceList);
            if (0 != nRet)
            {
                Console.WriteLine("NOT find Camer! {0:x8}", nRet);
                return null;
            }

            //在输出打印相机名称 
            for (int i = 0; i < m_pDeviceList.nDeviceNum; i++)
            {
                MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
                //网口相机
                if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
                {
                    IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
                    MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
                    if (gigeInfo.chUserDefinedName != "")
                    {
                        Console.WriteLine("GigE: " + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
                        CamerName.Add(gigeInfo.chSerialNumber);
                    }
                    else
                    {
                        Console.WriteLine("GigE: " + gigeInfo.chManufacturerName + " " + gigeInfo.chModelName + " (" + gigeInfo.chSerialNumber + ")");
                    }
                }
                //usb接口相机
                else if (device.nTLayerType == MyCamera.MV_USB_DEVICE)
                {
                    IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stUsb3VInfo, 0);
                    MyCamera.MV_USB3_DEVICE_INFO usbInfo = (MyCamera.MV_USB3_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_USB3_DEVICE_INFO));
                    if (usbInfo.chUserDefinedName != "")
                    {
                        Console.WriteLine("USB: " + usbInfo.chUserDefinedName + " (" + usbInfo.chSerialNumber + ")");
                    }
                    else
                    {
                        Console.WriteLine("USB: " + usbInfo.chManufacturerName + " " + usbInfo.chModelName + " (" + usbInfo.chSerialNumber + ")");
                    }
                }
            }
            if (m_pDeviceList.nDeviceNum == 0)
            {
                Console.WriteLine("未找到USB或者网口相机", 0);
                return null;
            }
            return CamerName;

        }
        /// <summary>
        /// 根据相机序列号开启相机
        /// </summary>
        /// <param name="CamerSerialization"></param>
        /// <returns></returns>
        public override bool OpenCamer(string CamerSerialization)
        {
            int nRet = 0;

            for (int i = 0; i < m_pDeviceList.pDeviceInfo.Length; i++)
            {
                device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
                IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
                MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
                if (gigeInfo.chSerialNumber== CamerSerialization)
                {
                    break;
                }
            }
            // ch:打开设备 | en:Open device
            if (null == HKMyCamera)
            {
                HKMyCamera = new MyCamera();
                if (null == HKMyCamera)
                {
                    return false;
                }
            }
            //循环执行1000次，用于连接相机
            for (int i = 0; i < 10; i++)
            {
                nRet = HKMyCamera.MV_CC_CreateDevice_NET(ref device);
                if (MyCamera.MV_OK != nRet)
                {
                    Thread.Sleep(1);
                    //输出错误信息
                    if (i == 9) Console.WriteLine("创建相机失败! {0:x8}", nRet);
                    continue;
                }

                nRet = HKMyCamera.MV_CC_OpenDevice_NET();
                if (MyCamera.MV_OK != nRet)
                {
                    HKMyCamera.MV_CC_DestroyDevice_NET();
                    Thread.Sleep(10);
                    if (i == 9) Console.WriteLine("打开相机失败! {0:x8}", nRet);
                }
                else
                {
                    break;
                }
            }


            // ch:探测网络最佳包大小(只对GigE相机有效) 
            if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
            {
                int nPacketSize = HKMyCamera.MV_CC_GetOptimalPacketSize_NET();
                if (nPacketSize > 0)
                {
                    nRet = HKMyCamera.MV_CC_SetIntValue_NET("GevSCPSPacketSize", (uint)nPacketSize);
                    if (nRet != MyCamera.MV_OK)
                    {
                        Console.WriteLine("Warning: Set Packet Size failed {0:x8}", nRet);
                    }
                }
                else
                {
                    Console.WriteLine("Warning: Get Packet Size failed {0:x8}", nPacketSize);
                }
            }

            //注册断线重连回调函数
            nRet = HKMyCamera.MV_CC_RegisterExceptionCallBack_NET(pCallBackFunc, IntPtr.Zero);
            if (MyCamera.MV_OK != nRet)
            {
                //ShowErrorMsg("Register expection callback failed!", nRet);
                return false;
            }
            GC.KeepAlive(pCallBackFunc);
            //注册图像回调函数
            ImageCallback = new MyCamera.cbOutputExdelegate(ImageCallbackFunc);
            nRet = HKMyCamera.MV_CC_RegisterImageCallBackEx_NET(ImageCallback, IntPtr.Zero);
            if (MyCamera.MV_OK != nRet)
            {
                Console.WriteLine("Register image callback failed!");
                return false;
            }


            //设置开启触发模式
            HKMyCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
            //设置开启软触发模式
            HKMyCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);

            //使用软触发命令
            nRet = HKMyCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");

            if (MyCamera.MV_OK != nRet)
            {
                m_bGrabbing = false;
                //              ShowErrorMsg("Start Grabbing Fail!", nRet);
                return false;
            }
            // ch:开始采集 
            nRet = HKMyCamera.MV_CC_StartGrabbing_NET();
            if (MyCamera.MV_OK != nRet)
            {
                Console.WriteLine("开启相机采集失败!  {0:x8}", nRet);
                return false;
            }
            Console.WriteLine("开启相机成功");
            return true;
        }
        /// <summary>
        /// 相机重连开启
        /// </summary>
        /// <param name="nMsgType"></param>
        /// <param name="pUser"></param>
        public override bool ReconnectCamer(string CamerName)
        {

                CloseCamer( );

                for (int j = 0; j < m_pDeviceList.pDeviceInfo.Length; j++)
                {
                    device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_pDeviceList.pDeviceInfo[j], typeof(MyCamera.MV_CC_DEVICE_INFO));
                    IntPtr buffer = Marshal.UnsafeAddrOfPinnedArrayElement(device.SpecialInfo.stGigEInfo, 0);
                    MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)Marshal.PtrToStructure(buffer, typeof(MyCamera.MV_GIGE_DEVICE_INFO));
                    if (gigeInfo.chSerialNumber == CamerName)
                    {
                        break;
                    }
                }
                int i = 0;
                // ch:打开设备 | en:Open Device
                while (true)
                {
                    int nRet = HKMyCamera.MV_CC_CreateDevice_NET(ref device);
                    i++;
                    //防止重连超时卡死
                    if (i > 10000)
                    {
                        Console.WriteLine("相机重连超时，请检查相机安装");
                        nRet = -1;
                        break;
                    }

                    if (MyCamera.MV_OK != nRet)
                    {
                        Thread.Sleep(5);
                        continue;
                    }

                    nRet = HKMyCamera.MV_CC_OpenDevice_NET();
                    if (MyCamera.MV_OK != nRet)
                    {
                        Thread.Sleep(5);
                        HKMyCamera.MV_CC_DestroyDevice_NET();
                        continue;
                    }
                    else
                    {
                        //nRet = InitCamera();
                        if (MyCamera.MV_OK != nRet)
                        {
                            Thread.Sleep(5);
                            HKMyCamera.MV_CC_DestroyDevice_NET();
                            continue;
                        }
                        break;
                    }

                }
            return true;
            
        }
        /// <summary>
        /// 清空相机
        /// </summary>
        public override bool CloseCamer()
        {
            // ch:停止采集 | en:Stop Grabbing
            HKMyCamera.MV_CC_StopGrabbing_NET();
            // ch:关闭设备 | en:Close Device
            HKMyCamera.MV_CC_CloseDevice_NET();
            HKMyCamera.MV_CC_DestroyDevice_NET();
            return true;
        }
        //回调图像传出变量
        void ImageCallbackFunc(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
        {
            Halcon_Image(pData, ref pFrameInfo, pUser);
        }
        public void Halcon_Image(IntPtr pData, ref MyCamera.MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
        {
            int nRet;
            HObject img = new HObject();
            IntPtr pImageBuf = IntPtr.Zero;
            int nImageBufSize = 0;
            IntPtr pTemp = IntPtr.Zero;
            if (IsColorPixelFormat(pFrameInfo.enPixelType))
            {
                if (pFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed)
                {
                    pTemp = pData;
                }
                else
                {
                    if (IntPtr.Zero == pImageBuf || nImageBufSize < (pFrameInfo.nWidth * pFrameInfo.nHeight * 3))
                    {
                        if (pImageBuf != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(pImageBuf);
                            pImageBuf = IntPtr.Zero;
                        }

                        pImageBuf = Marshal.AllocHGlobal((int)pFrameInfo.nWidth * pFrameInfo.nHeight * 3);
                        if (IntPtr.Zero == pImageBuf)
                        {
                            Console.WriteLine("图像采集为空");
                            return;
                        }
                        nImageBufSize = pFrameInfo.nWidth * pFrameInfo.nHeight * 3;
                    }

                    MyCamera.MV_PIXEL_CONVERT_PARAM stPixelConvertParam = new MyCamera.MV_PIXEL_CONVERT_PARAM();

                    stPixelConvertParam.pSrcData = pData;//源数据
                    stPixelConvertParam.nWidth = pFrameInfo.nWidth;//图像宽度
                    stPixelConvertParam.nHeight = pFrameInfo.nHeight;//图像高度
                    stPixelConvertParam.enSrcPixelType = pFrameInfo.enPixelType;//源数据的格式
                    stPixelConvertParam.nSrcDataLen = pFrameInfo.nFrameLen;

                    stPixelConvertParam.nDstBufferSize = (uint)nImageBufSize;
                    stPixelConvertParam.pDstBuffer = pImageBuf;//转换后的数据
                    stPixelConvertParam.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed;


                    nRet = HKMyCamera.MV_CC_ConvertPixelType_NET(ref stPixelConvertParam);//格式转换
                    if (MyCamera.MV_OK != nRet)
                    {
                        Console.WriteLine("图像转换异常");
                        return;
                    }
                    pTemp = stPixelConvertParam.pDstBuffer;
                }

                try
                {
                    HOperatorSet.GenImageInterleaved(out hPylonImage, (HTuple)pTemp, (HTuple)"rgb", (HTuple)pFrameInfo.nWidth, (HTuple)pFrameInfo.nHeight, -1, "byte", 0, 0, 0, 0, -1, 0);

                }
                catch (System.Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                    return;
                }
            }
            else if (IsMonoPixelFormat(pFrameInfo.enPixelType))
            {
                if (pFrameInfo.enPixelType == MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8)
                {
                    pTemp = pData;
                }
                else
                {
                    if (IntPtr.Zero == pImageBuf || nImageBufSize < (pFrameInfo.nWidth * pFrameInfo.nHeight))
                    {
                        if (pImageBuf != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(pImageBuf);
                            pImageBuf = IntPtr.Zero;
                        }

                        pImageBuf = Marshal.AllocHGlobal((int)pFrameInfo.nWidth * pFrameInfo.nHeight);
                        if (IntPtr.Zero == pImageBuf)
                        {
                            Console.WriteLine("图像采集为空");
                            return;
                        }
                        nImageBufSize = pFrameInfo.nWidth * pFrameInfo.nHeight;
                    }

                    MyCamera.MV_PIXEL_CONVERT_PARAM stPixelConvertParam = new MyCamera.MV_PIXEL_CONVERT_PARAM();

                    stPixelConvertParam.pSrcData = pData;//源数据
                    stPixelConvertParam.nWidth = pFrameInfo.nWidth;//图像宽度
                    stPixelConvertParam.nHeight = pFrameInfo.nHeight;//图像高度
                    stPixelConvertParam.enSrcPixelType = pFrameInfo.enPixelType;//源数据的格式
                    stPixelConvertParam.nSrcDataLen = pFrameInfo.nFrameLen;

                    stPixelConvertParam.nDstBufferSize = (uint)nImageBufSize;
                    stPixelConvertParam.pDstBuffer = pImageBuf;//转换后的数据
                    stPixelConvertParam.enDstPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8;
                    nRet = HKMyCamera.MV_CC_ConvertPixelType_NET(ref stPixelConvertParam);//格式转换
                    if (MyCamera.MV_OK != nRet)
                    {
                        Console.WriteLine("图像转换异常");
                        return;
                    }
                    pTemp = stPixelConvertParam.pDstBuffer; ;
                }
                try
                {
                    HOperatorSet.GenImage1Extern(out hPylonImage, "byte", pFrameInfo.nWidth, pFrameInfo.nHeight, pTemp, IntPtr.Zero);
                }
                catch (System.Exception ex)
                {
                    MessageBox.Show(ex.ToString());
                    return;
                }
            }
            else
            {
                Console.WriteLine("采集图像格式错误，不为彩色和黑白图像");
                return;
            }

            try
            {
                GetImage(hPylonImage);//调用相机基类的函数，用于传出变量
                hPylonImage.Dispose();
                m_bGrabbing = false;
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
                return;
            }
        }
        /// <summary>
        /// 设置相机曝光
        /// </summary>
        /// <param name="ExposureTime"></param>
        /// <returns></returns>
        public override bool SetExposureTime(int ExposureTime)
        {
            try
            {
                HKMyCamera.MV_CC_SetEnumValue_NET("ExposureAuto", 0);
                int nRet = HKMyCamera.MV_CC_SetFloatValue_NET("ExposureTime", ExposureTime);
                if (nRet != MyCamera.MV_OK)
                {
                    return false;
                }
                return true;
            }
            catch (Exception)
            {
                return false;
            }
           
        }
        /// <summary>
        /// 设置Gige相机心跳时间
        /// </summary>
        /// <param name="value"></param>
        public void SetHeartBeatTime(uint value)
        {
            try
            {
                //判断是否是网口相机
                if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
                {
                    HKMyCamera.MV_CC_SetHeartBeatTimeout_NET(value);
                }

            }
            catch (Exception)
            {

            }
        }

        bool m_bGrabbing = false;
        /// <summary>
        /// 单张采集
        /// </summary>
        public override bool OneGrap()
        {
            try
            {
                if (m_bGrabbing)
                {
                    Console.WriteLine("Camera is now Continue Grabing Images！");

                    return false;
                }
                else
                {
                    // ch:标志位置位true | en:Set position bit true
                    m_bGrabbing = true;

                    //设置开启触发模式
                    HKMyCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
                    //设置开启软触发模式
                    HKMyCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
                    int nRet;
                    //使用软触发命令
                    nRet = HKMyCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");

                    if (MyCamera.MV_OK != nRet)
                    {
                        m_bGrabbing = false;
                        return false;
                    }
                   // HeventSlim.Wait();
                    return true;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 开启硬触发
        /// </summary>
        /// <returns></returns>
        public override bool EncoderGrap()
        {
            try
            {
                if (m_bGrabbing)
                {
                    Console.WriteLine("Camera is now Continue Grabing Images！");
                    return false;
                }
                else
                {
                    // ch:标志位置位true | en:Set position bit true
                    m_bGrabbing = true;

                    HKMyCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
                    //设置使用硬触发模式
                    int nRet = HKMyCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);


                    if (MyCamera.MV_OK != nRet)
                    {
                        m_bGrabbing = false;
                        return false;
                    }
                    return true;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }
        /// <summary>
        /// 判断是否为彩色图像
        /// </summary>
        /// <param name="enType"></param>
        /// <returns></returns>
        private bool IsColorPixelFormat(MyCamera.MvGvspPixelType enType)
        {
            switch (enType)
            {
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_RGB8_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BGR8_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_RGBA8_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BGRA8_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_YUV422_YUYV_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGB12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerBG12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerRG12_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_BayerGR12_Packed:
                    return true;
                default:
                    return false;
            }
        }
        /// <summary>
        /// 判断图像是否是黑白图像
        /// </summary>
        /// <param name="enType"></param>
        /// <returns></returns>
        private bool IsMonoPixelFormat(MyCamera.MvGvspPixelType enType)
        {
            switch (enType)
            {
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono8:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12:
                case MyCamera.MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
                    return true;
                default:
                    return false;
            }
        }
    }
}

整体过程其实比较简单，由于海康相机没有像一些品牌相机一样可以直接使用序列号开启相机，所以我们需要通过对相机信息进行索引，根据索引到的相机序列号来开启相机。
如何显示图像：可以访问我文章开头的博客，通过编写相机通用类即可，程序中是有继承通用类，通过访问相机通用的获取图像数据，从而传输图像数据。具体可以查看相机通用类。

HALCON飞拍贴片机框架程序——硬件介绍
奔跑的郑的博客
06-02 750
相机我们换算下来1200万的精度也比较合适，所以采用了1200万卷帘相机，因为是静态拍摄，卷帘的性价比比较高。2.飞拍部分，这里对相机的速度要求较高，因为视野比较小，虽然精度要求高，我们换算下来160万精度可以到达，速度方面必须使用USB3.0口高帧率相机，光源部分需要突出物品的边缘，利于特征捕捉，所以使用0度环形光源；3.载具部分，这里要求精度较高，我们就使用了优于FA镜头的微距镜头，视野为30mm左右，静态拍摄，为了平衡精度和性价比，我们选用和振动盘部分一样的相机1200万网口面阵卷帘相机。
机器视觉开发教程——利用C#调用海康机器人工业相机SDK实现回调取图与软触发取图【含免费教程源码】
吾门的博客
09-09 2054
海康机器人工业相机SDK实现回调取图与软触发取图
Halcon与海康相机插件使用手册.pdf
08-12
halcon与海康相机搭载的图像采集模块dll使用方法。
海康工业相机飞拍硬触发接线及参数设置、调试
m0_73500215的博客
04-12 6272
工业相机触发方式介绍，相机I/O 电气特性与接线、硬触发接线电路原理图分享，事物接线演示。硬触发PC环境及相机参数设置，工业相机飞拍位置调试步骤。
相机硬触发接线升级篇，小白专属，手把手教学
最新发布
su桥木的博客
02-26 1733
在实际的运用过程中会遇到各种各样的设备和运用方式，比如有的光源控制器触发需要增加外部电源，有的方案需要将相机作为两个O口输出信号，用以控制成本，本文主要对接线方式和参数设置进行阐述。
halcon+C# 海康双相机采集源码
03-26
工业海康双相机采集demo用vs217开发（halcon与C#）
使用halcon解决工业相机外部触发模式下的超时问题
热门推荐
shmilyAshen的专栏
12-31 2万+
使用halcon解决工业相机外部触发模式下的超时问题
海康相机硬触发接线 -6pin
qq_40886870的博客
08-18 1万+
海康相机硬触发接线 -6pin
海康威视相机软触发无法获取图像
weixin_44656422的博客
03-26 1391
MV_CC_SetEnumValue_NET("TriggerMode", 1); //触发模式更改MV_CC_SetEnumValue_NET("TriggerSource", 7); //触发源改软触发MV_CC_SetCommandValue_NET("TriggerSoftware"); //发送指令这三个都要打开
海康工业相机触发模式抓图和AI目标检测
weixin_43422012的博客
12-22 2383
本文实现用海康工业相机，触发模式，开发调试用软件触发，实际用硬件触发抓图，调用目标检测接口
海康相机触发输入输出（含代码）
m0_56066265的博客
08-21 2755
软件设置：先设置触发模式，在设置触发源。
C# 联合 halcon编程读取海康相机，实现连续或者软触发取图模板匹配
01-26
1.实现了X64版本VS2022与高版本halcon23.05 联合编程 2.实现了vs调用海康威视类直接读取相机 3.实现了海康类转换成halcon图像 4.实现了hsmartwind缩放，平移，显示，画图功能 5.已经实现了模板匹配算法 与之前直接用halcon读取相机比较，速度更快，更稳定 //实现图像平移缩放 this.MouseWheel += new System.Windows.Forms.MouseEventHandler(this.my_MouseWheel); //读取相机 m_pDeviceList = new MyCamera.MV_CC_DEVICE_INFO_LIST(); //定义海康威视类，设置相机，读取图像 m_pMyCamera = new MyCamera(); 程序运行后，打开相机就可以操作 halcon 连续读取 ---是开启连续读取图像，并进行模板匹配 halcon读取 ---是开启软件触发功能，触发一次，读取一次 Thread hReceiveImageThreadHandle = new Thread(ReceiveIma
c#网口相机外触发SetFramegrabberCallback回调采图
09-29
c#海康网口相机外触发SetFramegrabberCallback回调采图，对于飞拍很有用 SetFramegrabberCallback的好处： 1，使用halcon自带的采集接口，避免了图像转换，采集效率高于SDK 2，避免了用户端轮询采集，资源占用少 3，...
halcon外触发采集、保存图片
洪流之源
11-24 2088
halcon外触发采集、保存图片
相机通用类之LMI激光三角相机（3D），软触发硬触发（飞拍），并输出halcon格式对象
m0_51559565的博客
11-14 2611
LMI相机的运行逻辑并不难，一个主要是如何配置LMI相机，另一个是如何转换格式图像。代码中提供了3种转换方式，分别有：GenTL格式，带标定数据的halcon类型，不带标定数据的halcon类型。最近完成一个关于LMI激光三角（3D相机）采图的demo，记录并说明用法。如何配置LMI相机后面会再开一份博客进行讲解。
海康工业相机（MV-CH050-90XM-C-NN）板卡硬触发采集
x2982778912的博客
01-25 1086
工业相机硬触发采图的简易案例
海康相机的触发模式
zxmyoung的博客
08-11 2万+
一、图像采集模式分类 相机的图像采集模式分为内触发模式与外触发模式。其中内触发模式包含连续采集、单帧采集两种形式；外触发模式包含软件触发、硬件外触发。本文以海康相机的软件平台作介绍，该软件去海康机器人官网下载。 内触发模式与外触发模式可以通过 Acquisition Control 下的 Trigger Mode 参数进行设置 Trigger Mode 选择 On 则为外触发模式， Trigger Mode 选择 Off 则为内触发模式。如图 二、内触发模式 ...
线阵相机的软触发与硬触发详解
家里蹲大学摸鱼学专业优秀毕业生的博客
07-22 9726
如果了解过线阵相机的工作原理后，就会想要知道如何触发线阵相机拍照。 无论何种触发方式，要保证线阵相机拍出的图片不压缩也不拉长，就要保证横向精度与纵向精度相等。 这样每个像素的宽与高对应的世界尺寸是一样的。 Ⅰ，在软触发下， 以下面的公式开篇： 横向精度=纵向精度 横向精度=FOV(mm) / 线阵相机像元尺寸(无量纲常量) 横向精度就是一个像素的宽对应世界范围的尺寸。 线阵相机像元尺寸就是这个相机多少K的，一般分为16384， 8192 ， 4096 等等。 FOV 为视野范围，要和相机搭载的镜头一起考虑。
海康相机sdk实现硬触发
07-23
### 回答1： 海康相机SDK可以通过软件控制相机完成硬触发功能。硬触发是指通过外部触发信号来控制相机的拍摄动作，而不是使用相机自带的按钮或菜单来进行拍摄。 首先，需要在代码中引入海康相机SDK的相关库文件，并进行初始化设置。接下来，可以使用SDK提供的函数来设置相机的工作模式为硬触发模式。这样，相机就会进入等待外部触发信号的状态。 在硬触发模式下，可以通过SDK提供的函数来设置触发信号的输入方式，例如选择使用相机的某个GPIO口作为触发信号的输入口。然后，可以设置触发信号的触发边沿，例如上升沿触发或下降沿触发。 当外部触发信号到达时，相机会立即执行拍摄操作，并将图像数据保存到相机的缓冲区中。通过SDK提供的函数，可以将缓冲区中的图像数据读取出来，进行处理或保存到本地。 需要注意的是，硬触发功能的具体实现可能会因相机型号而有所差异。在使用海康相机SDK实现硬触发时，建议参考SDK提供的开发文档和示例代码，根据实际情况进行相应的设置和操作。 总的来说，海康相机SDK提供了丰富的功能和接口，可以方便地实现硬触发功能。通过合理的设置和编程，可以实现按需触发拍摄，并获取高质量的图像数据。 ### 回答2： 海康相机SDK可以通过以下步骤实现硬触发功能： 1. 确定相机硬触发的接口类型：首先，需要了解所使用的具体相机硬触发接口类型，例如Gige Vision或USB3 Vision。 2. 初始化SDK：在代码中，需要先调用相机SDK的初始化函数，以确保能够正常使用相机的功能。 3. 配置相机参数：通过相机SDK提供的函数，设置相机的相关参数，包括图像分辨率、曝光时间、触发模式等。 4. 开启硬触发模式：使用相机SDK提供的函数，将相机设置为硬触发模式。根据相机接口类型的不同，可能会有一些特定的设置步骤，比如设置相机的触发信号源等。 5. 监听硬触发事件：通过在代码中设置回调函数，实时监听硬触发事件。当接收到硬触发事件时，触发回调函数，然后执行相应的处理逻辑。 6. 图像采集和保存：当硬触发事件触发后，相机会采集到图像数据。利用相机SDK提供的函数，可以将图像数据保存到指定位置，或进行进一步的处理和分析。 需要注意的是，不同型号的海康相机SDK的函数和接口可能会有所不同，因此具体的实现步骤会因相机型号和SDK版本的不同而有差异。在实际使用中，可以参考相应的海康相机SDK开发文档，根据实际情况进行相应的编码和配置。 ### 回答3： 海康相机SDK实现硬触发的过程如下： 1. 首先，我们需要确保相机已经连接到计算机并且SDK已经正确安装。 2. 在代码中，我们需要使用SDK提供的相机初始化函数，初始化相机的各种参数和配置。 3. 接下来，我们需要使用SDK中的触发模式函数，将相机设置为硬触发模式。这样可以使相机在接收到外部触发信号后，才会进行拍摄。 4. 在硬触发模式下，我们需要调用SDK中的设置触发源函数，将外部硬触发信号源绑定到相机上。这通常是通过连接一个外部硬触发装置，将其信号源与相机的触发输入接口相连实现的。 5. 启动相机，等待外部硬触发信号的到来。这时，只有在接收到外部硬触发信号后，相机才会执行拍摄操作。 6. 当相机接收到外部硬触发信号时，可以通过SDK中的拍摄函数进行图像的采集。根据需要，我们可以选择进行单帧拍摄或者连续拍摄。 7. 拍摄完成后，可以停止相机的采集。 8. 最后，我们可以对获取到的图像进行后续处理、保存或者展示。 需要注意的是，使用海康相机SDK进行硬触发时，我们需要在接口连接和硬件配置上进行一定的设置和调试。这包括正确连接硬触发源和相机的触发接口、调整相机的触发灵敏度以及外部触发设备的工作参数等等。同时，我们还需根据实际需求，进行适当的代码编写和错误处理，以确保硬触发的稳定性和准确性。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值