C#海康威视摄像头控制，将IntPtr转换成Bitmap图片

ReflexMechanism

已于 2022-11-07 15:23:01 修改

阅读量4.3k

点赞数 2

文章标签： c# .net ui

于 2022-11-07 14:59:18 首次发布

本文链接：https://blog.csdn.net/ReflexMechanism/article/details/127731348

版权

using DVPCameraType;
using MvCamCtrl.NET;
using OpenCvSharp;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace zqt_Control
{
    public class Camera_csb
    {
        #region 摄像头
        List<string> lsca = new List<string>();
        [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
        public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

        MyCamera.MV_CC_DEVICE_INFO_LIST m_stDeviceList = new MyCamera.MV_CC_DEVICE_INFO_LIST();
        private MyCamera m_MyCamera = new MyCamera();
        bool m_bGrabbing = false;
        Thread m_hReceiveThread = null;
        MyCamera.MV_FRAME_OUT_INFO_EX m_stFrameInfo = new MyCamera.MV_FRAME_OUT_INFO_EX();

        // ch:用于从驱动获取图像的缓存 | en:Buffer for getting image from driver
        UInt32 m_nBufSizeForDriver = 0;
        IntPtr m_BufForDriver = IntPtr.Zero;
        private static Object BufForDriverLock = new Object();
        MyCamera.MV_FRAME_OUT stFrameInfo = new MyCamera.MV_FRAME_OUT();

private static Camera_csb controller = null;

        public static Camera_csb GetController()
        {
            if (controller == null)
            {
                controller = new Camera_csb();
            }
            return controller;
        }

        public void InitCamrea()
        {
            DeviceListAcq();
            Open();
            StartGrab();
            SetParam("280000");
            //bnSaveJpg_Click();
        }

        /// <summary>
        /// 搜索所有相机
        /// </summary>
        public void DeviceListAcq()
        {
            // ch:创建设备列表 | en:Create Device List
            System.GC.Collect();
            //cbDeviceList.Items.Clear();
            m_stDeviceList.nDeviceNum = 0;
            int nRet = MyCamera.MV_CC_EnumDevices_NET(MyCamera.MV_GIGE_DEVICE | MyCamera.MV_USB_DEVICE, ref m_stDeviceList);
            if (0 != nRet)
            {
                //MessageBox.Show("Enumerate devices fail!");
                return;
            }

            // ch:在窗体列表中显示设备名 | en:Display device name in the form list
            for (int i = 0; i < m_stDeviceList.nDeviceNum; i++)
            {
                MyCamera.MV_CC_DEVICE_INFO device = (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_stDeviceList.pDeviceInfo[i], typeof(MyCamera.MV_CC_DEVICE_INFO));
                if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
                {
                    MyCamera.MV_GIGE_DEVICE_INFO gigeInfo = (MyCamera.MV_GIGE_DEVICE_INFO)MyCamera.ByteToStruct(device.SpecialInfo.stGigEInfo, typeof(MyCamera.MV_GIGE_DEVICE_INFO));

                    if (gigeInfo.chUserDefinedName != "")
                    {
                        //cbDeviceList.Items.Add("GEV: " + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
                        lsca.Add("GEV: " + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
                    }
                    else
                    {
                        lsca.Add("GEV: " + gigeInfo.chManufacturerName + " " + gigeInfo.chModelName + " (" + gigeInfo.chSerialNumber + ")");
                    }
                }
                else if (device.nTLayerType == MyCamera.MV_USB_DEVICE)
                {
                    //MyCamera.MV_USB3_DEVICE_INFO usbInfo = (MyCamera.MV_USB3_DEVICE_INFO)MyCamera.ByteToStruct(device.SpecialInfo.stUsb3VInfo, typeof(MyCamera.MV_USB3_DEVICE_INFO));
                    //if (usbInfo.chUserDefinedName != "")
                    //{
                    //    lsca.Add("U3V: " + usbInfo.chUserDefinedName + " (" + usbInfo.chSerialNumber + ")");
                    //}
                    //else
                    //{
                    //    lsca.Add("U3V: " + usbInfo.chManufacturerName + " " + usbInfo.chModelName + " (" + usbInfo.chSerialNumber + ")");
                    //}
                }
            }

}

        /// <summary>
        /// 接收数据
        /// </summary>
        public void ReceiveThreadProcess()
        {
            try
            {
                MyCamera.MV_DISPLAY_FRAME_INFO stDisplayInfo = new MyCamera.MV_DISPLAY_FRAME_INFO();
                int nRet = MyCamera.MV_OK;

                while (m_bGrabbing)
                {
                    nRet = m_MyCamera.MV_CC_GetImageBuffer_NET(ref stFrameInfo, 1000);
                    if (nRet == MyCamera.MV_OK)
                    {
                        lock (BufForDriverLock)
                        {
                            if (m_BufForDriver == IntPtr.Zero || stFrameInfo.stFrameInfo.nFrameLen > m_nBufSizeForDriver)
                            {
                                if (m_BufForDriver != IntPtr.Zero)
                                {
                                    Marshal.Release(m_BufForDriver);
                                    m_BufForDriver = IntPtr.Zero;
                                }

                                m_BufForDriver = Marshal.AllocHGlobal((Int32)stFrameInfo.stFrameInfo.nFrameLen);
                                if (m_BufForDriver == IntPtr.Zero)
                                {
                                    return;
                                }
                                m_nBufSizeForDriver = stFrameInfo.stFrameInfo.nFrameLen;
                            }

                            m_stFrameInfo = stFrameInfo.stFrameInfo;
                            CopyMemory(m_BufForDriver, stFrameInfo.pBufAddr, stFrameInfo.stFrameInfo.nFrameLen);
                        }

                        if (RemoveCustomPixelFormats(stFrameInfo.stFrameInfo.enPixelType))
                        {
                            m_MyCamera.MV_CC_FreeImageBuffer_NET(ref stFrameInfo);
                            continue;
                        }
                        //this.Dispatcher.Invoke(new Action(delegate
                        //{
                        //stDisplayInfo.hWnd = pictureBox1.Handle;
                        stDisplayInfo.pData = stFrameInfo.pBufAddr;
                        stDisplayInfo.nDataLen = stFrameInfo.stFrameInfo.nFrameLen;
                        stDisplayInfo.nWidth = stFrameInfo.stFrameInfo.nWidth;
                        stDisplayInfo.nHeight = stFrameInfo.stFrameInfo.nHeight;
                        stDisplayInfo.enPixelType = stFrameInfo.stFrameInfo.enPixelType;
                        m_MyCamera.MV_CC_DisplayOneFrame_NET(ref stDisplayInfo);
                        m_MyCamera.MV_CC_FreeImageBuffer_NET(ref stFrameInfo);

                    }
                    else
                    {
                        //if (bnTriggerMode.Checked)
                        //{
                        //    Thread.Sleep(5);
                        //}
                    }
                }
            }
            catch (Exception ex)
            {
                //MessageBox.Show(ex.Message);
            }
        }
        public bool RemoveCustomPixelFormats(MyCamera.MvGvspPixelType enPixelFormat)
        {
            Int32 nResult = ((int)enPixelFormat) & (unchecked((Int32)0x80000000));
            if (0x80000000 == nResult)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 打开设备
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void Open()
        {
            if (m_stDeviceList.nDeviceNum == 0)//|| cbDeviceList.SelectedIndex == -1
            {
                MessageBox.Show("No device, please select");
                return;
            }

            // ch:获取选择的设备信息 | en:Get selected device information//cbDeviceList.SelectedIndex
            MyCamera.MV_CC_DEVICE_INFO device =
                (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_stDeviceList.pDeviceInfo[0],
                                                              typeof(MyCamera.MV_CC_DEVICE_INFO));

            // ch:打开设备 | en:Open device
            if (null == m_MyCamera)
            {
                m_MyCamera = new MyCamera();
                if (null == m_MyCamera)
                {
                    return;
                }
            }

            int nRet = m_MyCamera.MV_CC_CreateDevice_NET(ref device);
            if (MyCamera.MV_OK != nRet)
            {
                return;
            }

            nRet = m_MyCamera.MV_CC_OpenDevice_NET();
            if (MyCamera.MV_OK != nRet)
            {
                m_MyCamera.MV_CC_DestroyDevice_NET();
                //MessageBox.Show("Device open fail!");
                return;
            }

            // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
            if (device.nTLayerType == MyCamera.MV_GIGE_DEVICE)
            {
                int nPacketSize = m_MyCamera.MV_CC_GetOptimalPacketSize_NET();
                if (nPacketSize > 0)
                {
                    nRet = m_MyCamera.MV_CC_SetIntValue_NET("GevSCPSPacketSize", (uint)nPacketSize);
                    if (nRet != MyCamera.MV_OK)
                    {
                        //MessageBox.Show("Set Packet Size failed!");
                    }
                }
                else
                {
                    //MessageBox.Show("Get Packet Size failed!");
                }
            }

            // ch:设置采集连续模式 | en:Set Continues Aquisition Mode
            m_MyCamera.MV_CC_SetEnumValue_NET("AcquisitionMode", (uint)MyCamera.MV_CAM_ACQUISITION_MODE.MV_ACQ_MODE_CONTINUOUS);
            m_MyCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_OFF);

        }
        /// <summary>
        /// 开始采集
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void StartGrab()
        {
            // ch:标志位置位true | en:Set position bit true
            m_bGrabbing = true;

m_hReceiveThread = new Thread(ReceiveThreadProcess);
m_hReceiveThread.Start();

            m_stFrameInfo.nFrameLen = 0;//取流之前先清除帧长度
            m_stFrameInfo.enPixelType = MyCamera.MvGvspPixelType.PixelType_Gvsp_Undefined;
            // ch:开始采集 | en:Start Grabbing
            int nRet = m_MyCamera.MV_CC_StartGrabbing_NET();
            if (MyCamera.MV_OK != nRet)
            {
                m_bGrabbing = false;
                m_hReceiveThread.Join();
                //MessageBox.Show("Start Grabbing Fail!");
                return;
            }

            // ch:控件操作 | en:Control Operation
            // SetCtrlWhenStartGrab();
        }
        //保存图片
        public void SaveJpg()
        {
            if (false == m_bGrabbing)
            {
                MessageBox.Show("Not Start Grabbing");
                Close();
                InitCamrea();// StartGrab();
                SaveJpg();
                //return;
            }

            if (RemoveCustomPixelFormats(m_stFrameInfo.enPixelType))
            {
                MessageBox.Show("Not Support!");
                return;
            }

MyCamera.MV_SAVE_IMG_TO_FILE_PARAM stSaveFileParam = new MyCamera.MV_SAVE_IMG_TO_FILE_PARAM();

            lock (BufForDriverLock)
            {
                if (m_stFrameInfo.nFrameLen == 0)
                {
                    MessageBox.Show("Save Jpeg Fail!");
                    return;
                }
                stSaveFileParam.enImageType = MyCamera.MV_SAVE_IAMGE_TYPE.MV_Image_Jpeg;
                stSaveFileParam.enPixelType = m_stFrameInfo.enPixelType;
                stSaveFileParam.pData = m_BufForDriver;
                stSaveFileParam.nDataLen = m_stFrameInfo.nFrameLen;
                stSaveFileParam.nHeight = m_stFrameInfo.nHeight;
                stSaveFileParam.nWidth = m_stFrameInfo.nWidth;
                stSaveFileParam.nQuality = 80;
                stSaveFileParam.iMethodValue = 2;
                stSaveFileParam.pImagePath = @"Image.jpg";// + stSaveFileParam.nWidth.ToString() + "_h" + stSaveFileParam.nHeight.ToString() + "_fn" + m_stFrameInfo.nFrameNum.ToString() + ".jpg";
                                                          //stSaveFileParam.pImagePath = @"\pic\tube\Image_w" + stSaveFileParam.nWidth.ToString() + "_h" + stSaveFileParam.nHeight.ToString() + "_fn" + m_stFrameInfo.nFrameNum.ToString() + ".jpg";
                Bitmap dst = null;
                //CopyMenImage(ref refFrame, m_BufForDriver, out dst);

                // 判断文件是否存在,并删除
                bool isFile = System.IO.File.Exists(Application.StartupPath + "/Image.jpg");
                if (isFile)
                {
                    // 删除文件
                    System.IO.File.Delete(Application.StartupPath + "/Image.jpg");
                }
                //GrabImage();
                //CopyMenImage(m_BufForDriver, out Bitmap dstn);

                int nRet = m_MyCamera.MV_CC_SaveImageToFile_NET(ref stSaveFileParam);
                if (MyCamera.MV_OK != nRet)
                {
                    MessageBox.Show("Save Jpeg Fail!");
                    return;
                }
            }

            MessageBox.Show("Save Succeed!");
        }
        //关闭相机
        public void Close()
        {
            // ch:取流标志位清零 | en:Reset flow flag bit
            if (m_bGrabbing == true)
            {
                m_bGrabbing = false;
                m_hReceiveThread.Join();
            }

            if (m_BufForDriver != IntPtr.Zero)
            {
                Marshal.Release(m_BufForDriver);
            }

            // ch:关闭设备 | en:Close Device
            m_MyCamera.MV_CC_CloseDevice_NET();
            m_MyCamera.MV_CC_DestroyDevice_NET();

}

        /// <summary>
        /// 将IntPtr转换成Bitmap图片
        /// </summary>
        /// <returns></returns>
        public Bitmap CopyMenImage()//IntPtr buff, out Bitmap dst
        {
            IntPtr buff = stFrameInfo.pBufAddr;
            buff = m_BufForDriver;
            PixelFormat pixeFormat = PixelFormat.Format24bppRgb;
            int picWidth = stFrameInfo.stFrameInfo.nWidth;
            int picHeight = stFrameInfo.stFrameInfo.nHeight;
            byte[] bBuff = new byte[stFrameInfo.stFrameInfo.nFrameLen];
            //byte[] bBuff = new byte[frame.uBytes];
            Bitmap dst = new Bitmap(picWidth, picHeight, pixeFormat);
            BitmapData bmpData = dst.LockBits(new Rectangle(0, 0, dst.Width, dst.Height), ImageLockMode.ReadWrite, pixeFormat);
            Marshal.Copy(buff, bBuff, 0, bBuff.Length);
            Marshal.Copy(bBuff, 0, bmpData.Scan0, bBuff.Length);
            dst.UnlockBits(bmpData);
            //dst.Save("Assets/res_tube111.jpg");
            return dst;
        }
        /// <summary>
        /// 设置参数
        /// </summary>
        /// <param name="Exposure">曝光</param>
        /// <param name="Gain">增益</param>
        /// <param name="FrameRate">帧率</param>
        private void SetParam(string Exposure = "", string Gain = "", string FrameRate = "")
        {
            int nRet = 0;
            try
            {
                if (Exposure != "")
                {
                    float.Parse(Exposure);
                    m_MyCamera.MV_CC_SetEnumValue_NET("ExposureAuto", 0);
                    nRet = m_MyCamera.MV_CC_SetFloatValue_NET("ExposureTime", float.Parse(Exposure));
                    if (nRet != MyCamera.MV_OK)
                    {
                        //ShowErrorMsg("Set Exposure Time Fail!", nRet);
                    }
                }
                if (Gain != "")
                {
                    float.Parse(Gain);
                    m_MyCamera.MV_CC_SetEnumValue_NET("GainAuto", 0);
                    nRet = m_MyCamera.MV_CC_SetFloatValue_NET("Gain", float.Parse(Gain));
                    if (nRet != MyCamera.MV_OK)
                    {
                        //ShowErrorMsg("Set Gain Fail!", nRet);
                    }
                }
                if (FrameRate != "")
                {
                    float.Parse(FrameRate);
                    nRet = m_MyCamera.MV_CC_SetFloatValue_NET("AcquisitionFrameRate", float.Parse(FrameRate));
                    if (nRet != MyCamera.MV_OK)
                    {
                        //ShowErrorMsg("Set Frame Rate Fail!", nRet);
                    }
                }

            }
            catch
            {
                //ShowErrorMsg("Please enter correct type!", 0);
                return;
            }
        }

#endregion

}
}