海康工业相机SDK操作（C#版）

已于 2024-07-30 22:10:21 修改
阅读量128 收藏 1
点赞数 2
文章标签： 数码相机
于 2024-07-30 17:13:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41375318/article/details/140801786
版权

海康工业相机SDK操作（C#版）

通过百度网盘分享的文件：海康相机
链接：https://pan.baidu.com/s/1ZDXJZ_a5GTQKITRXgHtJjA?pwd=1234
提取码：1234

一 添加虚拟相机（或者连接真实相机）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

打开开发文档

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

添加引用

在这里插入图片描述

面阵相机

在这里插入图片描述

using MvCameraControl;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 相机取像_Winform_
{
    public partial class Form1 : Form
    {
        readonly DeviceTLayerType enumTLayerType = DeviceTLayerType.MvGigEDevice | DeviceTLayerType.MvUsbDevice
           | DeviceTLayerType.MvGenTLGigEDevice | DeviceTLayerType.MvGenTLCXPDevice | DeviceTLayerType.MvGenTLCameraLinkDevice | DeviceTLayerType.MvGenTLXoFDevice;

        List<IDeviceInfo> deviceInfoList = new List<IDeviceInfo>();
        IDevice device = null;


        bool isGrabbing = false;        // ch:是否正在取图 | en: Grabbing flag
        bool isRecord = false;          // ch:是否正在录像 | en: Video record flag
        Thread receiveThread = null;    // ch:接收图像线程 | en: Receive image thread

        private IFrameOut frameForSave;                         // ch:获取到的帧信息, 用于保存图像 | en:Frame for save image
        private readonly object saveImageLock = new object();

        public Form1()
        {
            InitializeComponent();
            // 重要允许跨线程访问
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        /// <summary>
        /// 1.查找相机设备
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            RefreshDeviceList();
        }

        private void RefreshDeviceList()
        {
            // ch:创建设备列表 | en:Create Device List
            cbDeviceList.Items.Clear();
            int nRet = DeviceEnumerator.EnumDevices(enumTLayerType, out deviceInfoList);
            if (nRet != MvError.MV_OK)
            {
                MessageBox.Show("Enumerate devices fail!"+nRet);
                return;
            }

            // ch:在窗体列表中显示设备名 | en:Display device name in the form list
            for (int i = 0; i < deviceInfoList.Count; i++)
            {
                IDeviceInfo deviceInfo = deviceInfoList[i];
                if (deviceInfo.UserDefinedName != "")
                {
                    cbDeviceList.Items.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.UserDefinedName + " (" + deviceInfo.SerialNumber + ")");
                }
                else
                {
                    cbDeviceList.Items.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.ManufacturerName + " " + deviceInfo.ModelName + " (" + deviceInfo.SerialNumber + ")");
                }
            }

            // ch:选择第一项 | en:Select the first item
            if (deviceInfoList.Count != 0)
            {
                cbDeviceList.SelectedIndex = 0;
            }
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            if (deviceInfoList.Count == 0 || cbDeviceList.SelectedIndex == -1)
            {
                MessageBox.Show("No device, please select"+ 0);
                return;
            }

            // ch:获取选择的设备信息 | en:Get selected device information
            IDeviceInfo deviceInfo = deviceInfoList[cbDeviceList.SelectedIndex];


            /*
             
             
             * 重要
             
             
             */
            try
            {
                // ch:打开设备 | en:Open device
                device = DeviceFactory.CreateDevice(deviceInfo);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Create Device fail!" + ex.Message);
                return;
            }

            int result = device.Open();
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Open Device fail!"+ result);
                return;
            }

            //ch: 判断是否为gige设备 | en: Determine whether it is a GigE device
            if (device is IGigEDevice)
            {
                //ch: 转换为gigE设备 | en: Convert to Gige device
                IGigEDevice gigEDevice = device as IGigEDevice;

                // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
                int optionPacketSize;
                result = gigEDevice.GetOptimalPacketSize(out optionPacketSize);
                if (result != MvError.MV_OK)
                {
                    MessageBox.Show("Warning: Get Packet Size failed!"+ result);
                }
                else
                {
                    result = device.Parameters.SetIntValue("GevSCPSPacketSize", (long)optionPacketSize);
                    if (result != MvError.MV_OK)
                    {
                        MessageBox.Show("Warning: Set Packet Size failed!"+ result);
                    }
                }
            }

            // ch:设置采集连续模式 | en:Set Continues Aquisition Mode
            // 连续采图模式
            device.Parameters.SetEnumValueByString("AcquisitionMode", "Continuous");
            // 关闭触发模式
            device.Parameters.SetEnumValueByString("TriggerMode", "Off");

            // ch:控件操作 | en:Control operation

            // ch:获取参数 | en:Get parameters
            GetParam_Click();
        }

        private void GetParam_Click()
        {

            GetTriggerMode();

            IFloatValue floatValue;
            int result = device.Parameters.GetFloatValue("ExposureTime", out floatValue);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("ExposureTime" + floatValue.CurValue.ToString("F1")); 
            }

            result = device.Parameters.GetFloatValue("Gain", out floatValue);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("Gain" + floatValue.CurValue.ToString("F1"));
                
            }

            result = device.Parameters.GetFloatValue("ResultingFrameRate", out floatValue);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("ResultingFrameRate" + floatValue.CurValue.ToString("F1"));
             
            }


        }

        /// <summary>
        /// ch:获取触发模式 | en:Get Trigger Mode
        /// </summary>
        private void GetTriggerMode()
        {
            IEnumValue enumValue;
            int result = device.Parameters.GetEnumValue("TriggerMode", out enumValue);
            if (result == MvError.MV_OK)
            {
                if (enumValue.CurEnumEntry.Symbolic == "On")
                {
                   

                    result = device.Parameters.GetEnumValue("TriggerSource", out enumValue);
                    if (result == MvError.MV_OK)
                    {
                        if (enumValue.CurEnumEntry.Symbolic == "TriggerSoftware")
                        {
                        
                        }
                    }
                }
                else
                {
                  
                }
            }
        }

        /// <summary>
        ///  设置参数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {


            device.Parameters.SetEnumValue("ExposureAuto", 0);
            int result = device.Parameters.SetFloatValue("ExposureTime", 1000);
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Set Exposure Time Fail!"+ result);
            }

            device.Parameters.SetEnumValue("GainAuto", 0);
            result = device.Parameters.SetFloatValue("Gain", 3);
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Set Gain Fail!"+result);
            }

       
        }
        /// <summary>
        /// 取像
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button4_Click(object sender, EventArgs e)
        {
            try
            {
                // ch:标志位置位true | en:Set position bit true
                // 采图标志位
                isGrabbing = true;
                /*
                 
                 
                 * 重要
                 
                 
                 */
                receiveThread = new Thread(ReceiveThreadProcess);
                receiveThread.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Start thread failed!, " + ex.Message);
                throw;
            }

            // ch:开始采集 | en:Start Grabbing
            int result = device.StreamGrabber.StartGrabbing();



            if (result != MvError.MV_OK)
            {
                isGrabbing = false;
                receiveThread.Join();
                MessageBox.Show("Start Grabbing Fail!"+result);
                return;
            }


        }


        /// <summary>
        /// 取像线程（最重要的地方）
        /// </summary>
        public void ReceiveThreadProcess()
        {
            int nRet;

            Graphics graphics;   // ch:使用GDI在pictureBox上绘制图像 | en:Display frame using a graphics

            while (isGrabbing)
            {
                IFrameOut frameOut;

                nRet = device.StreamGrabber.GetImageBuffer(1000, out frameOut);
                if (MvError.MV_OK == nRet)
                {
                    if (isRecord)
                    {
                        device.VideoRecorder.InputOneFrame(frameOut.Image);
                    }

                    lock (saveImageLock)
                    {
                        frameForSave = frameOut.Clone() as IFrameOut;
                    }

                    #if !GDI_RENDER

                    /*
                     
                     
                     * 重要
                     
                     
                     */
                       device.ImageRender.DisplayOneFrame(pictureBox1.Handle, frameOut.Image);
                    #else
                                        // 使用GDI绘制图像
                                        try
                                        {
                                            using (Bitmap bitmap = frameOut.Image.ToBitmap())
                                            {
                                                if (graphics == null)
                                                {
                                                    graphics = pictureBox1.CreateGraphics();
                                                }

                                                Rectangle srcRect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
                                                Rectangle dstRect = new Rectangle(0, 0, pictureBox1.Width, pictureBox1.Height);
                                                graphics.DrawImage(bitmap, dstRect, srcRect, GraphicsUnit.Pixel);
                                            }
                                        }
                                        catch (Exception e)
                                        {
                                            device.StreamGrabber.FreeImageBuffer(frameOut);
                                            MessageBox.Show(e.Message);
                                            return;
                                        }
                    #endif


                    device.StreamGrabber.FreeImageBuffer(frameOut);
                }
                else
                {
                    
                }
            }
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // ch:取流标志位清零 | en:Reset flow flag bit
            //if (isGrabbing == true)
            //{
            //    if (isRecord)
            //    {
            //        if (false == isGrabbing)
            //        {
            //            ShowErrorMsg("Not Start Grabbing", 0);
            //            return;
            //        }

            //        int result = device.VideoRecorder.StopRecord();
            //        if (result != MvError.MV_OK)
            //        {
            //            ShowErrorMsg("Stop Record Fail!", result);
            //        }

            //        isRecord = false;
            //    }

            //    // ch:标志位设为false | en:Set flag bit false
            //    isGrabbing = false;
            //    receiveThread.Join();

            //    // ch:停止采集 | en:Stop Grabbing
            //    int result = device.StreamGrabber.StopGrabbing();
            //    if (result != MvError.MV_OK)
            //    {
            //        ShowErrorMsg("Stop Grabbing Fail!", result);
            //    }
            //}

            // ch:关闭设备 | en:Close Device
            if (device != null)
            {
                device.Close();
                device.Dispose();
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            // ch:停止采集 | en:Stop Grabbing
            int result = device.StreamGrabber.StopGrabbing();
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Stop Grabbing Fail!"+result);
            }

            // ch:关闭设备 | en:Close Device
            if (device != null)
            {
                device.Close();
                device.Dispose();
            }
        }

        private void button5_Click(object sender, EventArgs e)
        {

        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        /// <summary>
        /// 保存图像
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button6_Click(object sender, EventArgs e)
        {
            int result;

            try
            {
                ImageFormatInfo imageFormatInfo = new ImageFormatInfo();
                imageFormatInfo.FormatType = ImageFormatType.Bmp;

                result = SaveImage(imageFormatInfo);
                if (result != MvError.MV_OK)
                {
                    MessageBox.Show("Save Image Fail!"+result);
                    return;
                }
                else
                {
                    MessageBox.Show("Save Image Succeed!"+ 0);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Save Image Failed, " + ex.Message);
                return;
            }

        }

        private int SaveImage(ImageFormatInfo imageFormatInfo)
        {
            if (frameForSave == null)
            {
                throw new Exception("No vaild image");
            }

            string imagePath = "Image_w" + frameForSave.Image.Width.ToString() + "_h" + frameForSave.Image.Height.ToString() + "_fn" + frameForSave.FrameNum.ToString() + "." + imageFormatInfo.FormatType.ToString();

            lock (saveImageLock)
            {
                return device.ImageSaver.SaveImageToFile(imagePath, frameForSave.Image, imageFormatInfo, CFAMethod.Equilibrated);
            }
        }

    }
}

在这里插入图片描述

线扫相机

在这里插入图片描述

using MvCameraControl;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 相机取像_Winform_
{
    public partial class Form2 : Form
    {

        readonly DeviceTLayerType enumTLayerType = DeviceTLayerType.MvGigEDevice | DeviceTLayerType.MvUsbDevice
        | DeviceTLayerType.MvGenTLGigEDevice | DeviceTLayerType.MvGenTLCXPDevice | DeviceTLayerType.MvGenTLCameraLinkDevice | DeviceTLayerType.MvGenTLXoFDevice;

        IDevice device = null;
        List<IDeviceInfo> deviceInfos = new List<IDeviceInfo>();

        bool isGrabbing = false;
        Thread receiveThread = null;

        // ch:用于从驱动获取到的帧信息 | en:Frame info that getting image from driver
        IFrameOut frameForSave = null;
        private readonly Object lockForSaveImage = new Object();

        IEnumValue triggerSelector = null;  // 触发选项
        IEnumValue triggerMode = null;      // 触发模式
        IEnumValue triggerSource = null;    // 触发源
        IEnumValue pixelFormat = null;      // 像素格式
        IEnumValue imgCompressMode = null;  // HB模式
        IEnumValue preampGain = null;       // 模拟增益


        public Form2()
        {
            InitializeComponent();

            // 允许跨线程访问控件
            CheckForIllegalCrossThreadCalls = false;
        }

        /// <summary>
        /// 搜索相机
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            UpdateDeviceList();
        }

        /// <summary>
        /// ch:刷新设备列表 | en:Update devices list
        /// </summary>
        private void UpdateDeviceList()
        {
            // ch:枚举设备列表 | en:Enumerate Device List
            cmbDeviceList.Items.Clear();

            int result = DeviceEnumerator.EnumDevices(enumTLayerType, out deviceInfos);
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Enumerate devices fail!"+result);
                return;
            }

            // ch:在窗体列表中显示设备名 | en:Display device name in the form list
            for (int i = 0; i < deviceInfos.Count; i++)
            {
                IDeviceInfo deviceInfo = deviceInfos[i];
                if (deviceInfo.UserDefinedName != "")
                {
                    cmbDeviceList.Items.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.UserDefinedName + " (" + deviceInfo.SerialNumber + ")");
                }
                else
                {
                    cmbDeviceList.Items.Add(deviceInfo.TLayerType.ToString() + ": " + deviceInfo.ManufacturerName + " " + deviceInfo.ModelName + " (" + deviceInfo.SerialNumber + ")");
                }
            }

            // ch:选择第一项 | en:Select the first item
            if (deviceInfos.Count > 0)
            {
                cmbDeviceList.SelectedIndex = 0;
            }
            else
            {
                MessageBox.Show("No device"+ 0);
            }
            return;
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button2_Click(object sender, EventArgs e)
        {
            if (0 == deviceInfos.Count || -1 == cmbDeviceList.SelectedIndex)
            {
                MessageBox.Show("No device, please enumerate device"+0);
                return;
            }

            // ch:获取选择的设备信息 | en:Get selected device information
            IDeviceInfo deviceInfo = deviceInfos[cmbDeviceList.SelectedIndex];

            try
            {
                // ch:打开设备 | en:Open device
                /**
                 * 
                 * 重要
                 * 
                 * **/
                device = DeviceFactory.CreateDevice(deviceInfo);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Create Device fail!" + ex.Message);
                return;
            }

            int result = device.Open();
            if (result != MvError.MV_OK)
            {
                device.Dispose();
                device = null;

                MessageBox.Show("Open Device fail!"+result);
                return;
            }

            //ch: 判断是否为gige设备 | en: Determine whether it is a GigE device
            if (device is IGigEDevice)
            {
                //ch: 转换为gigE设备 | en: Convert to Gige device
                IGigEDevice gigEDevice = device as IGigEDevice;

                // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
                int optionPacketSize;
                result = gigEDevice.GetOptimalPacketSize(out optionPacketSize);
                if (result != MvError.MV_OK)
                {
                    MessageBox.Show("Warning: Get Packet Size failed!"+ result);
                }
                else
                {
                    result = device.Parameters.SetIntValue("GevSCPSPacketSize", (long)optionPacketSize);
                    if (result != MvError.MV_OK)
                    {
                        MessageBox.Show("Warning: Set Packet Size failed!"+result);
                    }
                }
            }

            // ch:设置采集连续模式 | en:Set Continues Aquisition Mode
            /*
             * 重要
             */
            device.Parameters.SetEnumValueByString("AcquisitionMode", "Continuous");
            device.Parameters.SetEnumValueByString("TriggerMode", "Off");

            // ch:获取参数 | en:Get parameters
            //GetImageCompressionMode();
            //GetPreampGain();
            //GetTriggerMode();
            //GetTriggerSelector();
            //GetTriggerSource();
            //GetPixelFormat();
            GetParam_Click();

        }

        private void GetParam_Click()
        {
            // ch:获取曝光参数 | en:Get ExposureTime
            IFloatValue exposureTime = null;
            int result = device.Parameters.GetFloatValue("ExposureTime", out exposureTime);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("获取曝光参数" + exposureTime.CurValue.ToString("F2"));

            }

            // ch:获取数字增益参数 | en:Get DigitalShift
            IFloatValue digitalShift = null;
            result = device.Parameters.GetFloatValue("DigitalShift", out digitalShift);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("获取数字增益参数" + digitalShift.CurValue.ToString("F2"));

            }

            // ch:获取行频使能开关 | en:Get AcquisitionLineRateEnable
            bool acqLineRateEnable = false;
            result = device.Parameters.GetBoolValue("AcquisitionLineRateEnable", out acqLineRateEnable);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("获取行频使能开关" + acqLineRateEnable.ToString());
     
            }

            // ch:获取行频设置值 | en:Get AcquisitionLineRate
            IIntValue acqLineRate = null;
            result = device.Parameters.GetIntValue("AcquisitionLineRate", out acqLineRate);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("获取行频设置值" + acqLineRate.CurValue.ToString());
                
            
            }

            // ch:获取行频实际值 | en:Get ResultingLineRate
            IIntValue resultLineRate = null;
            result = device.Parameters.GetIntValue("ResultingLineRate", out resultLineRate);
            if (result == MvError.MV_OK)
            {
                MessageBox.Show("获取行频设置值" + resultLineRate.CurValue.ToString());
                
            }
        }

        /// <summary>
        /// 设置相机参数
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button3_Click(object sender, EventArgs e)
        {

        }


        private void button4_Click(object sender, EventArgs e)
        {

        }
        /// <summary>
        /// 取像
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button5_Click(object sender, EventArgs e)
        {
            // ch:标志位置位 true | en:Set position bit true
            isGrabbing = true;

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

            // ch:开始采集 | en:Start Grabbing
            int result = device.StreamGrabber.StartGrabbing();
            if (result != MvError.MV_OK)
            {
                isGrabbing = false;
                receiveThread.Join();
                MessageBox.Show("Start Grabbing Fail!"+result);
                return;
            }
        }

        /// <summary>
        /// ch:接收图像线程 | en:Receive image thread process
        /// </summary>
        public void ReceiveThreadProcess()
        {
            IFrameOut frameOut = null;
            int result = MvError.MV_OK;

            while (isGrabbing)
            {
                result = device.StreamGrabber.GetImageBuffer(1000, out frameOut);
                if (result == MvError.MV_OK)
                {
                    // ch:保存图像数据用于保存图像文件 | en:Save frame info for save image
                    lock (lockForSaveImage)
                    {
                        frameForSave = frameOut.Clone() as IFrameOut;
                    }

                    // ch:渲染图像数据 | en:Display frame
                    device.ImageRender.DisplayOneFrame(pictureBox1.Handle, frameOut.Image);

                    // ch:释放帧信息 | en:Free frame info
                    device.StreamGrabber.FreeImageBuffer(frameOut);
                }
                else
                {
                  
                }
            }
        }
        private void button6_Click(object sender, EventArgs e)
        {
            int result;

            try
            {
                ImageFormatInfo imageFormatInfo = new ImageFormatInfo();
                imageFormatInfo.FormatType = ImageFormatType.Bmp;

                result = SaveImage(imageFormatInfo);
                if (result != MvError.MV_OK)
                {
                    MessageBox.Show("Save Image Fail!"+result);
                    return;
                }
                else
                {
                    MessageBox.Show("Save Image Succeed!"+0);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Save Image Failed, " + ex.Message);
                return;
            }
        }

        /// <summary>
        /// ch:保存图像 | en:Save image
        /// </summary>
        /// <param name="imageFormatInfo">ch:图像格式信息 | en:Image format info </param>
        /// <returns></returns>
        private int SaveImage(ImageFormatInfo imageFormatInfo)
        {
            if (frameForSave == null)
            {
                throw new Exception("No vaild image");
            }

            string imagePath = "Image_w" + frameForSave.Image.Width.ToString() + "_h" + frameForSave.Image.Height.ToString() + "_fn" + frameForSave.FrameNum.ToString() + "." + imageFormatInfo.FormatType.ToString();

            lock (lockForSaveImage)
            {
                return device.ImageSaver.SaveImageToFile(imagePath, frameForSave.Image, imageFormatInfo, CFAMethod.Equilibrated);
            }
        }

        private void button7_Click(object sender, EventArgs e)
        {
            // ch:停止采集 | en:Stop Grabbing
            int result = device.StreamGrabber.StopGrabbing();
            if (result != MvError.MV_OK)
            {
                MessageBox.Show("Stop Grabbing Fail!"+result);
            }

            // ch:取流标志位清零 | en:Reset flow flag bit
            if (isGrabbing == true)
            {
                isGrabbing = false;
                receiveThread.Join();
            }

            // ch:关闭设备 | en:Close Device
            if (device != null)
            {
                device.Close();
                device.Dispose();
            }
        }
    }
}

在这里插入图片描述

*Major*
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
「海康相机SDK+C#+halcon」通俗易懂源码：四相机测量项目，适用于工厂产线，《海康相机SDK+C#+halcon四相机测量项目源码解析及应用范例》
yqPrsUdg的博客
06-22 1634
C#+halcon提供了圆形拟合的功能，通过采集到的图像数据，可以实现对圆形目标的定位和测量。本文将结合海康相机SDK和C#+halcon编写的四相机测量项目源码，以通俗易懂的方式介绍其主要功能和实现原理，并分享一个实际工厂产线上的应用案例，帮助读者更好地理解和借鉴这个优秀的范例。四相机测量项目源码，海康相机SDK，C#+halcon，写得比较通俗易懂，四相机四种测量模式，某工厂产线曾使用的项目。主要功能有连接海康相机采图，模板匹配，圆形拟合，直线拟合，像素标定，保存图片，串口通讯，网口通讯。
C# 开源SDK 工业相机库 调用海康相机 大恒相机
老毛鸪的博客
04-18 2009
c# 相机库，含海康、大恒品牌2D相机的常用功能。底层采用回调+信号量模式封装 ，最大程度减小线程资源，提高采图效率。
C# 上位机之海康相机开发(SDK)
Dsxrrwe的博客
12-18 6073
发现工作中好多计算机视觉上位机项目都用海康相机，为了能够更好的学习和工作，我自己依据同事的源码和网上的一些总结编写本博客。通过本次学习，让我明白一点，无论学习什么技术都要学会自己看技术文档，而不是第一时间上网找源码。以工业相机SDK使用说明.chm为例，如何检索相机，打开相机，取流，抓取，保存图片，关闭相机，释放资源都有详细的介绍。
海康工业相机SDK C#开发示例程序.zip
12-25
海康工业相机SDK是专为开发者设计的一套用于与海康工业相机进行交互的软件开发工具包，它提供了丰富的API接口和示例代码，便于程序员使用C#等编程语言进行二次开发，实现对相机的各种功能控制。在这个"海康工业相机...
C# winform 大恒和海康相机sdk二次开发
04-23
在本文中，我们将深入探讨"C# WinForm 大恒和海康相机SDK二次开发"的主题。这个项目涉及到了C#编程语言、Windows Forms（WinForm）应用开发，以及使用大恒和海康威视相机的SDK进行图像处理的二次开发工作。我们将...
C# 海康工业相机图像采集 CCD.cs
12-11
调用海康SDK 实现相机的连接 图像的采集
海康工业相机二次开发demo
02-05
在本“海康工业相机二次开发demo”中，包含了三种主流编程语言——MFC（Microsoft Foundation Classes）、C#以及Java的开发实例，旨在帮助开发者快速理解和实现在各自开发环境中与海康工业相机的接口交互。...
海康威视工业相机 +Opencv+C#+WPF
12-30
在海康工业相机获取到图像后，我们可以通过OpenCV进行图像预处理，例如灰度转换、直方图均衡化、二值化等阈值处理。这些步骤有助于提高后续分析的准确性和效率。 阈值处理是计算机视觉中常用的一种技术，用于将图像...
OAK相机支持的图像传感器有哪些？
oakchina的博客
07-25 874
彩色传感器使用彩色滤光片阵列 （CFA） 捕获颜色信息。彩色滤光片阵列是一个由红色、绿色和蓝色滤光片组成的网格，它们放置在传感器的像素上，如下图所示。根据放置在特定像素上的颜色滤光片，只有该颜色波长的光通过滤光片，并在该像素位置被传感器捕获。
全球相机SoC市场展望与未来增长机遇：预计未来六年年复合增长率CAGR为8.9%
2401_86050993的博客
07-25 353
随着全球数码影像和移动设备的普及，相机SoC（系统级芯片）作为摄影和视频捕捉的核心组件，正逐渐成为消费电子和汽车安全系统的关键部分。本文基于最新的市场数据，探讨全球相机SoC市场的现状及未来发展趋势。
数据恢复教程：如何从硬盘、SD存储卡、数码相机中恢复误删除数据。
Geeker55的博客
07-25 1305
您正在摆弄 Android 设备。突然，您意外删除了一张或多张图片。不用担心，您总能找到一款价格实惠的数据恢复应用。这款先进的软件可帮助 Android 用户从硬盘、安全数字 (SD) 或存储卡以及数码相机中恢复已删除的数据。
【相机与图像】1. 相机模型的介绍：内参、外参、畸变参数
magic_ll的博客
07-24 1055
在实际相机中，会将成像平面上倒转的图像处理成与3D目标，直观上是一致的。相机坐标系下的点 除以最后一个维度（即该点距离相机成像平面的深度），即对最后一维度进行归一化处理，得到点P在相机的归一化平面上的归一化坐标。图像坐标系的原点位于感光芯片的中心（感光芯片是位于镜头背后的用于成像的小板子），x、y轴方向和相机坐标系的x、y轴相同。外参矩阵描述的是，世界坐标系下的坐标转换为相机坐标系下的坐标的过程。为了公式更好的转换和表达，引入了齐次坐标（在原有的坐标维度额外补充1维，数值为1），在这里像素的齐次坐标为。
ROS配置并同时驱动多个UVC相机（含功能包）
u014374826的博客
07-25 836
ROS配置并同时驱动多个UVC相机（含功能包）
全球相机控制面板市场展望与未来增长机遇：预计未来六年年复合增长率CAGR为4.3%
2401_86050993的博客
07-25 333
随着全球摄影器材和专业影像设备的需求增长，相机控制面板作为关键的交互组件，正逐渐成为摄影设备市场的重要组成部分。本文基于最新的市场数据，探讨全球相机控制面板市场的现状及未来发展趋势。
使用外接usb摄像头预览时拔出摄像头再插上相机ID会后移
小小博客
07-25 818
介绍了一下外接相机预览拔出为什么再次插入后ID会产生后移，并且如何解决
巴斯勒相机(Basler) ACE2 dart 系列说明和软件
m0_74183813的博客
07-26 246
巴斯勒相机(Basler) ACE2 dart 系列说明和软件。
前端分析-202307110039
最新发布
07-29
前端分析-202307110039
Oracle中文基础PPT
07-29
Oracle中文基础PPT 虽然是10g，但是学习Oracle，10g版本没问题 Less01_DB_Architecture_MB3.ppt Less02_Installation_MB3.ppt Less03_DB_DBCA_MB3.ppt Less04_Instance_TB3.ppt Less05_Storage_TB3.ppt Less06_Users_MB3.ppt Less07_Schema_TB3.ppt Less08_Data_TB3.ppt Less09_Undo_TB3.ppt Less10_Security_MB3.ppt Less11_Network_MB3.ppt Less12_ProactiveM_MB3.ppt Less13_Performance_TB3.ppt Less14_BR_Concepts_MB3.ppt Less15_Backups_TB3.ppt Less16_R
海康工业相机sdk开发
10-08
海康工业相机SDK是用于开发基于海康相机的应用程序的软件开发工具包。它提供了一系列的API和函数，用于控制相机的各种功能，如图像采集、图像处理、参数调整等。使用海康工业相机SDK可以方便地与相机进行通信，并进行自定义的开发和集成。 要进行海康工业相机SDK开发，首先需要下载并安装相应的SDK软件包。然后，在开发环境中配置SDK，并使用提供的API进行开发。具体步骤如下： 1. 下载SDK软件包：访问海康官网或联系销售代表获取相应的SDK软件包。根据自己的操作系统选择正确的版本进行下载。 2. 安装SDK软件包：将下载的SDK软件包解压到指定的目录，并按照安装说明进行安装。 3. 配置开发环境：根据使用的开发语言和开发环境，配置相应的编译器和开发工具。例如，如果使用C++进行开发，需要配置编译器和IDE。 4. 导入SDK库文件：在开发环境中创建一个新项目，并将SDK提供的库文件导入到项目中。这样可以在代码中使用SDK提供的函数和类。 5. 使用API进行开发：根据自己的需求，使用SDK提供的API进行开发。可以通过调用相应的函数来实现图像采集、图像处理和参数调整等功能。 在进行海康工业相机SDK开发时，可以参考SDK提供的文档和示例代码，了解API的使用方法和功能。同时，可以通过海康官方技术支持或开发者社区获取帮助和交流经验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值