海康相机大恒相机接口二次封装

最新推荐文章于 2025-05-25 21:50:24 发布
最新推荐文章于 2025-05-25 21:50:24 发布
阅读量913 收藏 1
点赞数 5
文章标签： 相机 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_46420972/article/details/137463203
版权 
包含海康相机与大恒相机二次封装

使用示例：
MCamera_hk hk1；
private void Form1_Load(object sender, EventArgs e)
{

    hk1 = new MCamera_hk(_process, 1);
    hk1.OpenOneCameraByUserName("xxxx");
    hk1.SetTriggerMode(1);
    hk1.SetCallBack();
    hk1.StartGetStream();
}
public void _process(Bitmap image)
{
    pictureBox1.Image = image;
}

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

using MvCamCtrl.NET;
using MvCamCtrl.NET.CameraParams;

using GxIAPINET;

namespace Camera
{

    public class MCamera_hk
    {

        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="pData"></param>
        /// <param name="pFrameInfo"></param>
        /// <param name="pUser"></param>
        private void ImageCallbackFunc(IntPtr pData, ref MV_FRAME_OUT_INFO_EX pFrameInfo, IntPtr pUser)
        {
            Console.WriteLine("Get one frame: Width[" + Convert.ToString(pFrameInfo.nWidth) + "] , Height[" + Convert.ToString(pFrameInfo.nHeight)
                                 + "] , FrameNum[" + Convert.ToString(pFrameInfo.nFrameNum) + "]");

            int width = pFrameInfo.nWidth;
            int height = pFrameInfo.nHeight;
            byte[] SrcData = new byte[pFrameInfo.nHeight * pFrameInfo.nWidth * channel];//图像数据
            Marshal.Copy(pData, SrcData, 0, SrcData.Length);

            Bitmap b = getBitmapFromByteStream(SrcData, height, width, channel);
            process(b);


        }

        #region 变量
        public CCamera hik = new CCamera();
        private int nRet = CErrorDefine.MV_OK;
        bool m_bIsDeviceOpen = false;       // ch:设备打开状态 | en:Is device open
        public bool m_bGrabbing = false;           // ch:设备取图状态
        private cbOutputExdelegate ImageCallback;

        Action<Bitmap> process;
        int channel;
        #endregion

        #region 对外接口

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="pro">传入的处理函数</param>
        /// <param name="ch">通道数</param>
        public MCamera_hk(Action<Bitmap> pro, int ch)
        {
            process = pro;
            channel = ch;
        }

        /// <summary>
        /// 根据ip指定相机
        /// </summary>
        /// <param name="str">ip地址</param>
        /// <returns>是否操作成功</returns>
        public bool OpenOneCameraByIP(string str)
        {
            List<CCameraInfo> ltDeviceList = new List<CCameraInfo>();
            GetDeviceList(ref ltDeviceList);

            for (int i = 0; i < ltDeviceList.Count; i++)
            {
                int nDevIndex = i;

                CGigECameraInfo cGigEDeviceInfo = (CGigECameraInfo)ltDeviceList[i];

                uint nIp1 = ((cGigEDeviceInfo.nCurrentIp & 0xff000000) >> 24);
                uint nIp2 = ((cGigEDeviceInfo.nCurrentIp & 0x00ff0000) >> 16);
                uint nIp3 = ((cGigEDeviceInfo.nCurrentIp & 0x0000ff00) >> 8);
                uint nIp4 = (cGigEDeviceInfo.nCurrentIp & 0x000000ff);

                string ss = nIp1 + "." + nIp2 + "." + nIp3 + "." + nIp4;
                if (ss == str)
                {
                    CCameraInfo stDevice = ltDeviceList[nDevIndex];

                    // ch:创建设备 | en:Create device
                    nRet = hik.CreateHandle(ref stDevice);
                    if (CErrorDefine.MV_OK != nRet)
                    {
                        Console.WriteLine("Create device failed:{0:x8}", nRet);
                        return false;
                    }

                    // ch:打开设备 | en:Open device
                    nRet = hik.OpenDevice();
                    if (CErrorDefine.MV_OK != nRet)
                    {
                        Console.WriteLine("Open device failed:{0:x8}", nRet);
                        return false;
                    }
                    m_bIsDeviceOpen = true;

                    // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
                    if (stDevice.nTLayerType == CSystem.MV_GIGE_DEVICE)
                    {
                        int nPacketSize = hik.GIGE_GetOptimalPacketSize();
                        if (nPacketSize > 0)
                        {
                            nRet = hik.SetIntValue("GevSCPSPacketSize", (uint)nPacketSize);
                            if (nRet != CErrorDefine.MV_OK)
                            {
                                Console.WriteLine("Set Packet Size failed!");
                            }
                        }
                    }


                }


            }

            return true;
        }

        /// <summary>
        /// 根据用户名指定相机
        /// </summary>
        /// <param name="str">用户名</param>
        /// <returns>是否操作成功</returns>
        public bool OpenOneCameraByUserName(string str)
        {
            List<CCameraInfo> ltDeviceList = new List<CCameraInfo>();
            GetDeviceList(ref ltDeviceList);

            for (int i = 0; i < ltDeviceList.Count; i++)
            {
                int nDevIndex = i;

                CGigECameraInfo cGigEDeviceInfo = (CGigECameraInfo)ltDeviceList[i];
                //  CUSBCameraInfo cGigEDeviceInfo = (CUSBCameraInfo)ltDeviceList[i];

                string ss = cGigEDeviceInfo.UserDefinedName;
                if (ss == str)
                {
                    CCameraInfo stDevice = ltDeviceList[nDevIndex];

                    // ch:创建设备 | en:Create device
                    nRet = hik.CreateHandle(ref stDevice);
                    if (CErrorDefine.MV_OK != nRet)
                    {
                        Console.WriteLine("Create device failed:{0:x8}", nRet);
                        return false;
                    }

                    // ch:打开设备 | en:Open device
                    nRet = hik.OpenDevice();
                    if (CErrorDefine.MV_OK != nRet)
                    {
                        Console.WriteLine("Open device failed:{0:x8}", nRet);
                        return false;
                    }
                    m_bIsDeviceOpen = true;
                }


            }

            return true;
        }

        /// <summary>
        /// 设置触发方式
        /// 0：关闭触发模式
        /// 1：软触发
        /// 2：硬触发
        /// </summary>
        /// <param name="index">触发模式序号</param>
        /// <returns></returns>
        public bool SetTriggerMode(int index)
        {
            if (index == 0)//触发模式关
            {
                nRet = hik.SetEnumValue("TriggerMode", (uint)MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);
                if (CErrorDefine.MV_OK != nRet)
                {
                    Console.WriteLine("Set TriggerMode failed:{0:x8}", nRet);
                    return false;
                }

            }
            else if (index == 1)//触发模式开  软触发
            {
                nRet = hik.SetEnumValue("TriggerMode", (uint)MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
                if (CErrorDefine.MV_OK != nRet)
                {
                    Console.WriteLine("Set TriggerMode failed:{0:x8}", nRet);
                    return false;
                }
                // ch:触发源设为软触发 | en:Set trigger source as Software
                hik.SetEnumValue("TriggerSource", (uint)MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);

            }
            else if (index == 2)//触发模式开  硬触发
            {
                nRet = hik.SetEnumValue("TriggerMode", (uint)MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);
                if (CErrorDefine.MV_OK != nRet)
                {
                    Console.WriteLine("Set TriggerMode failed:{0:x8}", nRet);
                    return false;
                }
                //设置触发方式
                hik.SetEnumValue("TriggerSource", (uint)MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
            }

            return true;
        }

        /// <summary>
        /// 单次触发
        /// </summary>
        /// <returns></returns>
        public bool OneSoftTrigger()
        {
            // ch:触发命令 | en:Trigger command
            int nRet = hik.SetCommandValue("TriggerSoftware");
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Trigger Software Fail!");
                return false;
            }
            Console.WriteLine("Trigger One Time!");
            return true;
        }

        /// <summary>
        /// 设置回调函数
        /// </summary>
        /// <returns></returns>
        public bool SetCallBack()
        {
            // ch:注册回调函数 | en:Register image callback
            ImageCallback = new cbOutputExdelegate(ImageCallbackFunc);
            nRet = hik.RegisterImageCallBackEx(ImageCallback, IntPtr.Zero);
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Register image callback failed!");
                return false;
            }
            return true;
        }

        /// <summary>
        /// 开始取流
        /// </summary>
        /// <returns></returns>
        public bool StartGetStream()
        {
            // ch:前置配置 | en:pre-operation
            int nRet = NecessaryOperBeforeGrab();
            if (CErrorDefine.MV_OK != nRet)
            {
                return false;
            }

            nRet = hik.StartGrabbing();
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Start grabbing failed:{0:x8}", nRet);
                return false;
            }
            m_bGrabbing = true;
            return true;
        }

        /// <summary>
        /// 关闭相机  销毁设备
        /// </summary>
        /// <returns></returns>
        public bool CloseCamera()
        {
            // ch:关闭设备 | en:Close device
            if (true == m_bIsDeviceOpen)
            {
                nRet = hik.CloseDevice();
                if (CErrorDefine.MV_OK != nRet)
                {
                    Console.WriteLine("Close device failed:{0:x8}", nRet);
                    return false;
                }
            }
            m_bGrabbing = false;

            // ch:销毁设备 | en:Destroy device
            nRet = hik.DestroyHandle();
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Destroy device failed:{0:x8}", nRet);
                return false;
            }

            m_bIsDeviceOpen = false;
            Console.WriteLine("Camera offline!");
            return true;
        }


        #endregion

        #region 私有方法

        //获取设备列表
        private bool GetDeviceList(ref List<CCameraInfo> ltDeviceList)
        {

            // ch:枚举设备 | en:Enum device
            nRet = CSystem.EnumDevices(CSystem.MV_GIGE_DEVICE | CSystem.MV_USB_DEVICE, ref ltDeviceList);
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Enum device failed:{0:x8}", nRet);
                return false;
            }
            Console.WriteLine("Enum device count : " + Convert.ToString(ltDeviceList.Count));
            if (0 == ltDeviceList.Count)
            {
                return false;
            }
            return true;
        }

        PixelFormat m_enBitmapPixelFormat = PixelFormat.DontCare;
        public Bitmap m_pcBitmap = null;
        private Int32 NecessaryOperBeforeGrab()
        {
            // ch:取图像宽 | en:Get Iamge Width
            CIntValue pcWidth = new CIntValue();
            int nRet = hik.GetIntValue("Width", ref pcWidth);
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Get Width Info Fail!");
                return nRet;
            }

            // ch:取图像高 | en:Get Iamge Height
            CIntValue pcHeight = new CIntValue();
            nRet = hik.GetIntValue("Height", ref pcHeight);
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Get Height Info Fail!");
                return nRet;
            }

            // ch:取像素格式 | en:Get Pixel Format
            CEnumValue m_pcPixelFormat = new CEnumValue();
            nRet = hik.GetEnumValue("PixelFormat", ref m_pcPixelFormat);
            if (CErrorDefine.MV_OK != nRet)
            {
                Console.WriteLine("Get Pixel Format Fail!");
                return nRet;
            }

            // ch:设置bitmap像素格式
            if ((Int32)MvGvspPixelType.PixelType_Gvsp_Undefined == (Int32)m_pcPixelFormat.CurValue)
            {

                Console.WriteLine("Unknown Pixel Format!");
                return CErrorDefine.MV_E_UNKNOW;
            }
            else if (IsMonoData((MvGvspPixelType)m_pcPixelFormat.CurValue))
            {
                m_enBitmapPixelFormat = PixelFormat.Format8bppIndexed;
            }
            else
            {
                m_enBitmapPixelFormat = PixelFormat.Format24bppRgb;
            }

            if (null != m_pcBitmap)
            {
                m_pcBitmap.Dispose();
                m_pcBitmap = null;
            }
            m_pcBitmap = new Bitmap((Int32)pcWidth.CurValue, (Int32)pcHeight.CurValue, m_enBitmapPixelFormat);

            // ch:Mono8格式，设置为标准调色板 | en:Set Standard Palette in Mono8 Format
            if (PixelFormat.Format8bppIndexed == m_enBitmapPixelFormat)
            {
                ColorPalette palette = m_pcBitmap.Palette;
                for (int i = 0; i < palette.Entries.Length; i++)
                {
                    palette.Entries[i] = Color.FromArgb(i, i, i);
                }
                m_pcBitmap.Palette = palette;
            }

            return CErrorDefine.MV_OK;
        }
        private Boolean IsMonoData(MvGvspPixelType enGvspPixelType)
        {
            switch (enGvspPixelType)
            {
                case MvGvspPixelType.PixelType_Gvsp_Mono8:
                case MvGvspPixelType.PixelType_Gvsp_Mono10:
                case MvGvspPixelType.PixelType_Gvsp_Mono10_Packed:
                case MvGvspPixelType.PixelType_Gvsp_Mono12:
                case MvGvspPixelType.PixelType_Gvsp_Mono12_Packed:
                    return true;

                default:
                    return false;
            }
        }
        private Boolean IsColorData(MvGvspPixelType enGvspPixelType)
        {
            switch (enGvspPixelType)
            {
                case MvGvspPixelType.PixelType_Gvsp_BayerGR8:
                case MvGvspPixelType.PixelType_Gvsp_BayerRG8:
                case MvGvspPixelType.PixelType_Gvsp_BayerGB8:
                case MvGvspPixelType.PixelType_Gvsp_BayerBG8:
                case MvGvspPixelType.PixelType_Gvsp_BayerGR10:
                case MvGvspPixelType.PixelType_Gvsp_BayerRG10:
                case MvGvspPixelType.PixelType_Gvsp_BayerGB10:
                case MvGvspPixelType.PixelType_Gvsp_BayerBG10:
                case MvGvspPixelType.PixelType_Gvsp_BayerGR12:
                case MvGvspPixelType.PixelType_Gvsp_BayerRG12:
                case MvGvspPixelType.PixelType_Gvsp_BayerGB12:
                case MvGvspPixelType.PixelType_Gvsp_BayerBG12:
                case MvGvspPixelType.PixelType_Gvsp_BayerGR10_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerRG10_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerGB10_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerBG10_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerGR12_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerRG12_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerGB12_Packed:
                case MvGvspPixelType.PixelType_Gvsp_BayerBG12_Packed:
                case MvGvspPixelType.PixelType_Gvsp_RGB8_Packed:
                case MvGvspPixelType.PixelType_Gvsp_YUV422_Packed:
                case MvGvspPixelType.PixelType_Gvsp_YUV422_YUYV_Packed:
                    return true;

                default:
                    return false;
            }
        }
        private Bitmap getBitmapFromByteStream(byte[] imgByte, int imgH, int imgW, int channel)
        {
            //申请目标位图的变量，并将其内存区域锁定
            Bitmap bitmap = null;
            if (channel == 3)
            {
                bitmap = new Bitmap(imgW, imgH, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
            }
            else if (channel == 1)
            {
                bitmap = new Bitmap(imgW, imgH, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
            }
            else if (channel == 4)
            {
                bitmap = new Bitmap(imgW, imgH, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            }
            else
            {
                return bitmap;
            }

            BitmapData bitmapData = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, imgW, imgH), ImageLockMode.WriteOnly, bitmap.PixelFormat);

            //获取图像参数
            int stride = bitmapData.Stride; //扫描线的宽度
            int offset = stride - imgW * channel;        //显示宽度与扫描线宽度的问题
            IntPtr iptr = bitmapData.Scan0;    //获取bitmapdata的内存起始位置
            int scanbytes = stride * imgH;   //用stride宽度，表示这是内存区域的大小

            int posScan = 0, posReal = 0;
            byte[] pixelvalues = new byte[scanbytes];

            if (0 != offset)
            {
                for (int x = 0; x < imgH; x++)
                {
                    for (int y = 0; y < imgW * channel; y++)
                    {
                        pixelvalues[posScan++] = imgByte[posReal++];
                    }
                    posScan += offset;
                }
                Marshal.Copy(pixelvalues, 0, iptr, scanbytes);
            }
            else
            {
                Marshal.Copy(imgByte, 0, iptr, scanbytes);
            }

            bitmap.UnlockBits(bitmapData);

            if (channel == 1)
            {
                //从伪彩改为灰度
                var pal = bitmap.Palette;
                for (int j = 0; j < 256; j++)
                    pal.Entries[j] = System.Drawing.Color.FromArgb(j, j, j);
                bitmap.Palette = pal;
            }

            return bitmap;
        }
        #endregion
    }


    public class MCamera_daheng
    {
        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="objUserParam"></param>
        /// <param name="objIFrameData"></param>
        private void ImageCallbackFunc(object objUserParam, IFrameData objIFrameData)
        {
            Console.WriteLine(SN + " 回调触发");
            if (m_bIsColor)
            {
                GX_VALID_BIT_LIST emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
                emValidBits = __GetBestValudBit(objIFrameData.GetPixelFormat());
                IntPtr pBufferColor = objIFrameData.ConvertToRGB24(emValidBits, GX_BAYER_CONVERT_TYPE_LIST.GX_RAW2RGB_NEIGHBOUR, false);
                CameraData = new Bitmap((int)objIFrameData.GetWidth(), (int)objIFrameData.GetHeight(), (int)objIFrameData.GetWidth() * 3, System.Drawing.Imaging.PixelFormat.Format24bppRgb, pBufferColor);

            }
            else
            {
                //MCamera_daheng objdhCamera = objUserParam as MCamera_daheng;
                CameraData = new Bitmap((int)objIFrameData.GetWidth(), (int)objIFrameData.GetHeight(), (int)objIFrameData.GetWidth(), System.Drawing.Imaging.PixelFormat.Format8bppIndexed, objIFrameData.GetBuffer());

                //添加调色板
                ColorPalette palette;
                palette = CameraData.Palette;
                int i = 0;
                for (i = 0; i <= 255; i++)
                {
                    palette.Entries[i] = System.Drawing.Color.FromArgb(i, i, i);
                }
                CameraData.Palette = palette;
            }
            process(CameraData);

        }

        #region 变量
        Action<Bitmap> process;
        int channel;

        string SN;


        static List<IGXDeviceInfo> listGXDeviceInfo;                ///<设备信息表  
        static IGXFactory m_objIGXFactory = null;                   ///<Factory对像

        IGXDevice m_objIGXDevice = null;                            ///<设备对像
        IGXStream m_objIGXStream = null;                            ///<流对像
        IGXFeatureControl m_objIGXFeatureControl = null;            ///<远端设备属性控制器对像
        IGXFeatureControl m_objIGXStreamFeatureControl = null;      ///<流层属性控制器对象
        bool m_bIsOpen = false;                                     ///<设备打开状态
        bool m_bIsSnap = false;                                     ///<发送开采命令标识                                             
        int m_nPayloadSize = 0;                                     ///<图像数据大小
        int CamIndex = 0;                                           ///<相机序号
        Bitmap CameraData;                                          ///<输出bitmap图像   
        static int OutCamIndex = 0;                                 ///<将相机的序号输出类外
        public delegate void OutPutData(int index, Bitmap objdata); ///<声明一个委托类型
        OutPutData inPutFunc;                                       ///<定义一个委托对象
        bool m_isStartGrab = false;                                 ///<标志是否开始了流通道采集                                                                   
        public bool m_bIsColor = false;                                    ///<是否支持彩色相机

        #endregion

        #region 对外接口

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="pro">回调函数中处理函数</param>
        /// <returns></returns>
        public MCamera_daheng(Action<Bitmap> pro, int chan)
        {
            //使用其他接口之前，必须执行初始化
            IGXFactory.GetInstance().Init();

            process = pro;
            channel = chan;
        }

        /// <summary>
        /// 根据SN打开相机
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public bool OpenOneCameraBySN(string str)
        {

            List<IGXDeviceInfo> listGXDeviceInfo = new List<IGXDeviceInfo>();

            IGXFactory.GetInstance().UpdateAllDeviceList(200, listGXDeviceInfo);

            Console.WriteLine("当前设备个数：" + listGXDeviceInfo.Count);
            // 判断当前连接设备个数
            if (listGXDeviceInfo.Count <= 0)
            {
                Console.WriteLine("未发现设备");
                return false;
            }
            int i;
            for (i = 0; i < listGXDeviceInfo.Count; i++)
            {
                string s = listGXDeviceInfo[i].GetSN();
                if (s == str)
                {
                    break;
                }
            }
            if (i >= listGXDeviceInfo.Count)
            {
                Console.WriteLine("未找到与所输SN对应的设备");
                return false;
            }
            SN = str;

            //按照sn打开设备
            m_objIGXDevice = IGXFactory.GetInstance().OpenDeviceBySN(str, GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
            m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();

            //打开流通道
            if (null != m_objIGXDevice)
            {
                m_objIGXStream = m_objIGXDevice.OpenStream(0);

                m_objIGXStreamFeatureControl = m_objIGXStream.GetFeatureControl();
            }
            // a = objFunc;
            m_nPayloadSize = (int)m_objIGXDevice.GetRemoteFeatureControl().GetIntFeature("PayloadSize").GetValue();
            //获取是否为彩色相机
            string strValue = null;
            if (m_objIGXDevice.GetRemoteFeatureControl().IsImplemented("PixelColorFilter"))
            {
                strValue = m_objIGXDevice.GetRemoteFeatureControl().GetEnumFeature("PixelColorFilter").GetValue();

                if ("None" != strValue)
                {
                    m_bIsColor = true;
                }
            }


            // 建议用户在打开网络相机之后，根据当前网络环境设置相机的流通道包长值，
            // 以提高网络相机的采集性能,设置方法参考以下代码。
            GX_DEVICE_CLASS_LIST objDeviceClass = m_objIGXDevice.GetDeviceInfo().GetDeviceClass();
            if (GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_GEV == objDeviceClass)
            {
                // 判断设备是否支持流通道数据包功能
                if (true == m_objIGXFeatureControl.IsImplemented("GevSCPSPacketSize"))
                {
                    // 获取当前网络环境的最优包长值
                    uint nPacketSize = m_objIGXStream.GetOptimalPacketSize();
                    // 将最优包长值设置为当前设备的流通道包长值
                    m_objIGXFeatureControl.GetIntFeature("GevSCPSPacketSize").SetValue(nPacketSize);
                }
            }


            m_bIsOpen = true;

            Console.WriteLine(SN + " 设置打开成功");
            return true;
        }

        /// <summary>
        /// 根据IP地址打开相机  待修改
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public bool OpenOneCameraByIP(string str)
        {

            List<IGXDeviceInfo> listGXDeviceInfo = new List<IGXDeviceInfo>();

            IGXFactory.GetInstance().UpdateAllDeviceList(200, listGXDeviceInfo);

            Console.WriteLine("当前设备个数：" + listGXDeviceInfo.Count);
            // 判断当前连接设备个数
            if (listGXDeviceInfo.Count <= 0)
            {
                Console.WriteLine("未发现设备");
                return false;
            }

            //按照sn打开设备
            m_objIGXDevice = IGXFactory.GetInstance().OpenDeviceByIP(str, GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
            m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();

            //打开流通道
            if (null != m_objIGXDevice)
            {
                m_objIGXStream = m_objIGXDevice.OpenStream(0);
            }
            // a = objFunc;
            m_nPayloadSize = (int)m_objIGXDevice.GetRemoteFeatureControl().GetIntFeature("PayloadSize").GetValue();
            //获取是否为彩色相机
            string strValue = null;
            if (m_objIGXDevice.GetRemoteFeatureControl().IsImplemented("PixelColorFilter"))
            {
                strValue = m_objIGXDevice.GetRemoteFeatureControl().GetEnumFeature("PixelColorFilter").GetValue();

                if ("None" != strValue)
                {
                    m_bIsColor = true;
                }
            }

            m_bIsOpen = true;

            return true;
        }

        /// <summary>
        /// 根据MAC地址打开相机  待修改
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public bool OpenOneCameraByMAC(string str)
        {

            List<IGXDeviceInfo> listGXDeviceInfo = new List<IGXDeviceInfo>();

            IGXFactory.GetInstance().UpdateAllDeviceList(200, listGXDeviceInfo);

            Console.WriteLine("当前设备个数：" + listGXDeviceInfo.Count);
            // 判断当前连接设备个数
            if (listGXDeviceInfo.Count <= 0)
            {
                Console.WriteLine("未发现设备");
                return false;
            }

            //按照sn打开设备
            m_objIGXDevice = IGXFactory.GetInstance().OpenDeviceByMAC(str, GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
            m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();

            //打开流通道
            if (null != m_objIGXDevice)
            {
                m_objIGXStream = m_objIGXDevice.OpenStream(0);
            }
            // a = objFunc;
            m_nPayloadSize = (int)m_objIGXDevice.GetRemoteFeatureControl().GetIntFeature("PayloadSize").GetValue();
            //获取是否为彩色相机
            string strValue = null;
            if (m_objIGXDevice.GetRemoteFeatureControl().IsImplemented("PixelColorFilter"))
            {
                strValue = m_objIGXDevice.GetRemoteFeatureControl().GetEnumFeature("PixelColorFilter").GetValue();

                if ("None" != strValue)
                {
                    m_bIsColor = true;
                }
            }

            m_bIsOpen = true;

            return true;
        }

        /// <summary>
        /// 设置曝光时间
        /// </summary>
        /// <param name="exp"></param>
        /// <returns></returns>
        public bool SetExposureTime(double exp)
        {
            //获取当前相机的曝光值、最小值、最大值和单位
            if (null != m_objIGXFeatureControl)
            {
                double dMin, dMax;
                dMin = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMin();
                dMax = m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetMax();
                //判断输入值是否在曝光时间的范围内
                //若大于最大值则将曝光值设为最大值
                if (exp > dMax)
                {
                    exp = dMax;
                    Console.WriteLine(SN + " 所设曝光大于最大值 已设为最大值" + dMax);
                }
                //若小于最小值将曝光值设为最小值
                if (exp < dMin)
                {
                    exp = dMin;
                    Console.WriteLine(SN + " 所设曝光小于最小值 已设为最大值" + dMin);
                }

                m_objIGXFeatureControl.GetFloatFeature("ExposureTime").SetValue(exp);

                Console.WriteLine(SN + " 设置曝光成功");
                return true;
            }
            Console.WriteLine(SN + " 设置曝光失败");
            return false;


        }

        /// <summary>
        /// 设置增益
        /// </summary>
        /// <param name="gain"></param>
        /// <returns></returns>
        public bool SetGain(double gain)
        {
            //当前相机的增益值、最小值、最大值
            if (null != m_objIGXFeatureControl)
            {
                double dMin, dMax;
                dMin = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMin();
                dMax = m_objIGXFeatureControl.GetFloatFeature("Gain").GetMax();

                //判断输入值是否在增益值的范围内
                //若输入的值大于最大值则将增益值设置成最大值
                if (gain > dMax)
                {
                    gain = dMax;
                    Console.WriteLine(SN + " 所设增益大于最大值 已设为最大值" + dMax);
                }

                //若输入的值小于最小值则将增益的值设置成最小值
                if (gain < dMin)
                {
                    gain = dMin;
                    Console.WriteLine(SN + " 所设增益大于最大值 已设为最大值" + dMax);
                }

                m_objIGXFeatureControl.GetFloatFeature("Gain").SetValue(gain);

                Console.WriteLine(SN + "设置增益成功");
                return true;
            }
            Console.WriteLine(SN + "设置增益失败");
            return false;

        }

        /// <summary>
        /// 设置触发方式
        /// 0：关闭触发模式
        /// 1：软触发
        /// 2：硬触发
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public bool SetTriggerMode(int index)
        {
            if (m_objIGXFeatureControl == null)
            {
                Console.WriteLine("SN输入错误 设置触发失败");
                return false;
            }

            if (index == 0)
            {
                m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("Off");
            }
            else if (index == 1)
            {
                m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("On");
                m_objIGXFeatureControl.GetEnumFeature("TriggerSource").SetValue("Software");
                Console.WriteLine(SN + " 触发模式设置成功！");
            }
            else if (index == 2)
            {
                m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("On");
                m_objIGXFeatureControl.GetEnumFeature("TriggerSource").SetValue("Line0");
            }

            return true;
        }

        /// <summary>
        /// 单次软触发
        /// </summary>
        /// <returns></returns>
        public bool OneSoftTrigger()
        {
            //发送软触发命令
            if (null != m_objIGXFeatureControl)
            {
                m_objIGXFeatureControl.GetCommandFeature("TriggerSoftware").Execute();
                Console.WriteLine(SN + "单次触发成功");
                return true;
            }
            Console.WriteLine(SN + "单次触发失败");
            return false;
        }
        /// <summary>
        /// 开始取流
        /// </summary>
        /// <returns></returns>
        public bool StartGetStream()
        {
            if (null != m_objIGXStreamFeatureControl)
            {
                try
                {
                    //设置流层Buffer处理模式为OldestFirst
                    m_objIGXStreamFeatureControl.GetEnumFeature("StreamBufferHandlingMode").SetValue("OldestFirst");
                }
                catch (Exception)
                {
                }
            }

            //开启采集流通道
            if (null != m_objIGXStream)
            {
                //RegisterCaptureCallback第一个参数属于用户自定参数(类型必须为引用
                //类型)，若用户想用这个参数可以在委托函数中进行使用
                m_objIGXStream.RegisterCaptureCallback(this, ImageCallbackFunc);
                m_objIGXStream.StartGrab();
                m_isStartGrab = true;
            }

            //发送开采命令
            if (null != m_objIGXFeatureControl)
            {
                m_objIGXFeatureControl.GetCommandFeature("AcquisitionStart").Execute();
            }
            m_bIsSnap = true;


            return true;
        }

        /// <summary>
        /// 关闭取流
        /// </summary>
        /// <returns></returns>
        public bool CloseCamera()
        {
            if (m_bIsSnap)
            {
                if (null != m_objIGXFeatureControl)
                {
                    m_objIGXFeatureControl.GetCommandFeature("AcquisitionStop").Execute();
                    m_objIGXFeatureControl = null;

                    m_objIGXStreamFeatureControl = null;
                }
            }
            m_bIsSnap = false;
            Console.WriteLine(SN + " 取流已停止！");
            //停止流通道、注销采集回调和关闭流
            if (null != m_objIGXStream)
            {
                //停止流通道采集
                m_objIGXStream.StopGrab();
                //注销采集回调函数
                m_objIGXStream.UnregisterCaptureCallback();
                m_objIGXStream.Close();
                m_objIGXStream = null;
            }
            //关闭设备
            if (null != m_objIGXDevice)
            {
                m_objIGXDevice.Close();
                m_objIGXDevice = null;
            }
            Console.WriteLine(SN + " 设备已关闭");
            m_bIsOpen = false;
            return true;
        }


        #endregion

        #region 私有方法
        /// <summary>
        /// 通过GX_PIXEL_FORMAT_ENTRY获取最优Bit位
        /// </summary>
        /// <param name="em">图像数据格式</param>
        /// <returns>最优Bit位</returns>
        private GX_VALID_BIT_LIST __GetBestValudBit(GX_PIXEL_FORMAT_ENTRY emPixelFormatEntry)
        {
            GX_VALID_BIT_LIST emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
            switch (emPixelFormatEntry)
            {
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG8:
                    {
                        emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
                        break;
                    }
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10:
                    {
                        emValidBits = GX_VALID_BIT_LIST.GX_BIT_2_9;
                        break;
                    }
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12:
                    {
                        emValidBits = GX_VALID_BIT_LIST.GX_BIT_4_11;
                        break;
                    }
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO14:
                    {
                        //暂时没有这样的数据格式待升级
                        break;
                    }
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG16:
                    {
                        //暂时没有这样的数据格式待升级
                        break;
                    }
                default:
                    break;
            }
            return emValidBits;
        }

        #endregion

        ~MCamera_daheng()
        {
            //关闭设备之后，不能再调用其他任何库接口
            IGXFactory.GetInstance().Uninit();
        }

    }
}
网口工业相机丢包根因及排查方法
weixin_46200354的博客
10-17 1000
UDP（User Datagram Protocol）和TCP（Transmission Control Protocol）是两种不同的网络传输协议，它们在数据传输的可靠性、速度和应用场景方面有着各自的特点和优势。TCP与UDP的区别总结：1、TCP面向连接，三次握手和四次挥手；UDP是无连接，发送数据前不需要建立连接。2、TCP提供可靠服务，按序传送数据；UDP尽最大努力交付，但不保证可靠交付。3、UDP具有较好的实效性，工作效率比TCP高，适用于高速传输和实时性较好的通信。
VS(C#)调用海康工业相机SDK采集图像及基本功能设定
热门推荐
大樱桃的博客
02-12 4万+
VS(C#)调用海康工业相机SDK获取图像及功能设定 简介 由于工作关系，本人最近使用到了海康的网口及USB3.0接口的工业相机。现将相关内容进行整理记录。 开发环境 64位VS2013 +C# Halcon12 海康MVS3.0.0 引用海康相机动态库（MvCameraControl.Net.dll） 在VS项目文件中添加添加引用，如下图 引用MVS安装目录下MVS\Development\D...
winfrom大恒工业相机SDK二次开发、C#联合halcon开发
susan的博客
12-18 2459
winfrom大恒工业相机SDK二次开发、C#联合halcon开发
C# 获取海康相机
john_and_jane的博客
05-18 5785
C#获取海康相机
C#学习笔记——（29）海康威视工业相机C#例程问题汇总
屿十_
05-07 4451
参考文章或链接 https://www.hikrobotics.com/service/soft.htm?type=1 https://www.51halcon.com/thread-3999-1-1.html https://blog.youkuaiyun.com/kucoffee12/article/details/88884804 关于using MvCamCtrl.NET 在打开Sample文件夹...
【无标题】
m0_46495157的博客
02-27 373
【代码】【无标题】
相机通用类之海康相机，软触发硬触发（飞拍），并输出halcon格式对象
m0_51559565的博客
11-14 6094
如何显示图像：可以访问我文章开头的博客，通过编写相机通用类即可，程序中是有继承通用类，通过访问相机通用的获取图像数据，从而传输图像数据。具体可以查看相机通用类。整体过程其实比较简单，由于海康相机没有像一些品牌相机一样可以直接使用序列号开启相机，所以我们需要通过对相机信息进行索引，根据索引到的相机序列号来开启相机。
C# winform 大恒和海康相机sdk二次开发
04-23
在本文中，我们将深入探讨"C# WinForm 大恒和海康相机SDK二次开发"的主题。这个项目涉及到了C#编程语言、Windows Forms（WinForm）应用开发，以及使用大恒和海康威视相机的SDK进行图像处理的二次开发工作。我们将...
常见工业相机Basler Hikvision Daheng Mvviewr二次开发流程 c# C++代码
07-25
常见相机(大恒、大华、海康、Basler)SDK的封装特点： 1，接口统一(名字、方法、属性....); 2, 输出脱离了对具体硬件SDK的应用; 3, 本次发布只提供X64 4, 提供的DEMO为VS2010, WPF的形式; 5, DEMO中提供两种方法调用...
工业相机SDK封装及C# C++二次开发教程
资源摘要信息:"工业相机二次开发流程概述" 1. 工业相机SDK封装特点 工业相机在应用中通常需要二次开发，以便于集成到不同的系统和应用中。SDK（Software Development Kit，软件开发工具包）是提供给开发者的软件包...
C# 连接海康威视
weixin_44713908的博客
01-07 1万+
using HalconDotNet; using MvCamCtrl.NET; using System; using System.Collections.Generic; using System.Linq; using System.Runtime.InteropServices; using System.Text; using System.Threading.Tasks; us...
未经处理的异常：System.BadImageFormatException:“未能加载文件或程序集“GxIAPINET
weixin_46022853的博客
04-22 3995
问题抛出 在VS2017中，利用C#开发Winform时，出现未经处理异常【System.BadImageFormatException:“未能加载文件或程序集“GxIAPINET, Version=1.0.7972.20585, Culture=neutral, PublicKeyToken=null”或它的某一个依赖项。试图加载格式不正确的程序。”】 解决办法 遇到这种问题，在确保【动态链接库】等配置无误的前提下，可检查软件的操作属性配置是否正确（目前大部分机器都是64位，而部分软件/界面是基于32位
海康彩色相机SDK开发，与Halcon 联合使用，可搭载Halcon 的各项视觉算法。
家里蹲大学摸鱼学专业优秀毕业生的博客
05-06 7818
本文的硬件是海康彩色相机MV CE013-50GC, 传感器类型CCD，相机分辨率12809603。 软件平台是.NET，视觉算法库是Halcon。 本文利用的开发框架是海康的官方Demo： BasicDemo。 如图： 本Demo 的界面如下： 只是在右侧多开了个HWindowControl 而已。 具体开发步骤： 首先引入MvCameraControl.Net.dll ， 具体路径是： C:\Program Files (x86)\MVS\Development\Bin\win64 AnyCpu
C#实现MCP Client 与 LLM 连接，抓取网页内容功能！
最新发布
成长的足迹
05-25 365
本文介绍了如何使用C#实现MCP Client与大型语言模型（LLM）的对接。主要内容包括： 添加依赖库Microsoft.Extensions.AI.OpenAI和Microsoft.Extensions.AI，以简化AI模型集成。 实现OpenAI客户端： 初始化OpenAI客户端并启用函数调用功能 配置API密钥、服务端点和模型ID 添加系统提示消息初始化对话 处理用户查询： 异步处理自然语言查询 支持MCP工具调用 维护对话上下文 日志功能： 输出AI调用的工具信息 使用不同颜色区分普通消息和工具调
C#对象初始化语句：优雅创建对象的黑科技
钢铁男儿
05-23 515
提升代码可读性减少冗余构造函数支持动态初始化组合。
synchronized 实现原理
qq_40589140的博客
05-23 644
Java中的synchronized关键字通过对象头、Monitor机制和锁升级过程实现线程同步。对象头包含Mark Word和Klass Pointer，Mark Word存储锁状态信息。Monitor机制管理线程竞争，锁升级过程根据竞争情况从无锁、偏向锁、轻量级锁到重量级锁动态调整。synchronized在字节码中通过monitorenter和monitorexit指令实现，支持可重入性和排他性。其优势在于JVM自动管理锁、锁升级机制和可重入性，适用于低竞争或快速实现同步的场景。
C# Unity容器详解
exlink2012的专栏
05-22 916
Unity容器是Microsoft开发的一个轻量级、可扩展的依赖注入(DI)容器，是.NET应用程序中实现控制反转(IoC)的强大工具。本文将深入探讨Unity容器的核心概念、使用方法以及在实际项目中的应用场景。
C# 按行写入txt大量数据
csdn_aspnet的专栏，请点击博客主页右上角三个点中的私信联系
05-23 3474
在 C# 中高效写入大量数据到文本文件时，建议使用 StreamWriter 并逐行写入，避免一次性加载全部数据到内存。// 示例：逐行写入 100 万条数据// 使用 StreamWriter 并启用自动刷新缓冲区（或手动控制）i++)string line = $"这是第 {i} 行数据";// 可选：每写入 N 行手动刷新一次（平衡性能与内存）
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牛奶奥利奥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值