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

最新推荐文章于 2024-08-21 11:43:04 发布
最新推荐文章于 2024-08-21 11:43:04 发布
阅读量149 收藏 1
点赞数
分类专栏： 工业相机 文章标签： 人工智能 计算机视觉 算法 机器学习
原文链接：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;
        }
    }
}
}

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

LeonDL168
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
海康工业相机飞拍硬触发接线及参数设置、调试
m0_73500215的博客
04-12 3368
工业相机触发方式介绍，相机I/O 电气特性与接线、硬触发接线电路原理图分享，事物接线演示。硬触发PC环境及相机参数设置，工业相机飞拍位置调试步骤。
VS(C#)调用海康工业相机SDK采集图像及基本功能设定
Sunny_love_you的博客
10-19 6177
1.引用海康相机动态库（MvCameraControl.Net.dll） 2.把SDK里的事件改成方法，进行调用 namespace 窗体 { public partial class ucCamera : UserControl { MyCamera.MV_CC_DEVICE_INFO_LIST m_pDeviceList; //设备列表 private MyCamera m_pMyCamera; //设备对象 // ch:用于从驱动获取图像的缓存 | e
海康工业相机触发模式抓图和AI目标检测
weixin_43422012的博客
12-22 1300
本文实现用海康工业相机，触发模式，开发调试用软件触发，实际用硬件触发抓图，调用目标检测接口
海康相机触发输入输出（含代码）
最新发布
m0_56066265的博客
08-21 300
软件设置：先设置触发模式，在设置触发源。
C#调用海康SDK，更改拍照方式--触发源
WorkHard_w的博客
10-09 1108
海康工业相机SDK存图的设计与编写。
海康威视相机软触发无法获取图像
weixin_44656422的博客
03-26 884
MV_CC_SetEnumValue_NET("TriggerMode", 1); //触发模式更改MV_CC_SetEnumValue_NET("TriggerSource", 7); //触发源改软触发MV_CC_SetCommandValue_NET("TriggerSoftware"); //发送指令这三个都要打开
海康相机的触发模式
热门推荐
zxmyoung的博客
08-11 2万+
一、图像采集模式分类 相机的图像采集模式分为内触发模式与外触发模式。其中内触发模式包含连续采集、单帧采集两种形式；外触发模式包含软件触发、硬件外触发。本文以海康相机的软件平台作介绍，该软件去海康机器人官网下载。 内触发模式与外触发模式可以通过 Acquisition Control 下的 Trigger Mode 参数进行设置 Trigger Mode 选择 On 则为外触发模式， Trigger Mode 选择 Off 则为内触发模式。如图 二、内触发模式 ...
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# 与 Halcon 联合编程连接海康威视相机.txt
12-08
C# 与 Halcon 联合编程连接海康威视相机 private MyCamera m_pMyCamera = new MyCamera(); byte[] m_pBufForSaveImage = new byte[60 * 1024 * 1024]; HWindow m_Window = new HWindow(); public int nRet = MyCamera.MV_OK; MyCamera.cbOutputExdelegate ImageCallback; MyCamera device = ne
halcon控制海康威视相机采图并转换
07-27
用halcon控制海康威视相机进行采图并且将其采集到的图片转换为hobject格式供halcon分析
海康相机SDK二次开发与Halcon混合编程.7z
07-09
在海康相机SDK的基础上进行的二次开发，其次就是在Qt上实现这个相机，还有就是将原始图像数据转换为Halcon的，然后再通过Halcon算子对图像进行处理。
halcon+C# 海康双相机采集源码
03-26
在本文中，我们将深入探讨如何使用C#编程语言与Halcon计算机视觉库相结合，实现海康双相机的数据采集。这个项目是基于Visual Studio 2017开发的，旨在为工业应用提供一个实用的示例。 首先，让我们理解C#在计算机...
c#网口相机外触发SetFramegrabberCallback回调采图
09-29
c#海康网口相机外触发SetFramegrabberCallback回调采图，对于飞拍很有用 SetFramegrabberCallback的好处： 1，使用halcon自带的采集接口，避免了图像转换，采集效率高于SDK 2，避免了用户端轮询采集，资源占用少 3，...
海康工业相机C++二次开发
05-03
使用海康工业相机的库文件进行的二次开发 全部使用的C++开发在VS2019，目前是在Qt环境中开发的 要想在MFC下使用，就需要单独找我了 只需要在VS2019环境下包含include文件，lib文件就可以，再将dll放到exe目录下
Halcon 进阶 三 C#实现 Halcon与工业相机（海康），视觉解析二维码
yuchenlove_的专栏
01-13 9260
Halcon与工业相机（海康），视觉解析二维码图像结果工业相机连接halcon解码 高速解码 适合多码关联、采集
C#联合Halcon视觉框架，可以根据项目配置工程，选择对应halcon脚本，可以编译修改脚本，调试相机
OkAkxpLhCm的博客
11-23 2009
在本文中，我们将讨论如何使用C#联合Halcon视觉框架，实现项目配置工程，选择对应的Halcon脚本，编译修改脚本，调试相机，创建模板，查看检测信息，生成履历，保存历史图像，并与三菱FX5U进行以太网通讯，使用的相机为海康网口SDK，Halcon版本为17.12。C#联合Halcon视觉框架，可以根据项目配置工程，选择对应halcon脚本，可以编译修改脚本，调试相机，创建模板，可以查看检测信息，生产履历，保存历史图像，跟三菱FX5U以太网通讯，相机是海康网口sdk，halcon版本17.12，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值