C#海康相机控制类

原创 已于 2024-09-11 10:02:54 修改 · 379 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2024-07-22 11:03:17 首次发布
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MvCamCtrl.NET;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.Drawing;
using System.IO;

namespace BasicDemo
{
    public class CameraHelper
    {
        [DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
        public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

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

        // ch:用于从驱动获取图像的缓存 | en:Buffer for getting image from driver
        private UInt32 m_nBufSizeForDriver = 0;

        private IntPtr m_BufForDriver = IntPtr.Zero;
        private static Object BufForDriverLock = new Object();
        private List<string> cbDeviceList = new List<string>();

        public bool bnTriggerMode = true;//触发模式

        public void Load(string id)
        {
            DeviceListAcq();//获取相机列表
            Open(id);//打开相机
            StartTriggerMode();//设置软触发模式
            //StartGrab();//开始采集
        }

        private Thread workerThread;

        public Bitmap Photograph()
        {
            int i = 0;
        A:

            TriggerExec();//软触发

            //Bitmap btmp = GetPicture();//获取照片
            Bitmap btmp = GetPicturen();
            if (btmp == null)
            {
                i++;
                if (i > 5)
                {
                    return null;
                }
                TriggerExec();//软触发
                goto A;
            }
            SaveImage(btmp);
            m_stFrameInfo = new MyCamera.MV_FRAME_OUT_INFO_EX();
            return btmp;
        }

        //获取设备列表
        public void DeviceListAcq()
        {
            // ch:创建设备列表 | en:Create Device List
            System.GC.Collect();
            cbDeviceList = new List<string>();
            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)
            {
                ShowErrorMsg("Enumerate devices fail!", 0);
                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.Add("GEV: " + gigeInfo.chUserDefinedName + " (" + gigeInfo.chSerialNumber + ")");
                    }
                    else
                    {
                        cbDeviceList.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 != "")
                    {
                        cbDeviceList.Add("U3V: " + usbInfo.chUserDefinedName + " (" + usbInfo.chSerialNumber + ")");
                    }
                    else
                    {
                        cbDeviceList.Add("U3V: " + usbInfo.chManufacturerName + " " + usbInfo.chModelName + " (" + usbInfo.chSerialNumber + ")");
                    }
                }
            }
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="LastFourCode">后四位相机Id</param>
        public void Open(string LastFourCode)
        {
            if (m_stDeviceList.nDeviceNum == 0)
            {
                ShowErrorMsg("No device, please select", 0);
                return;
            }
            int id = cbDeviceList.FindIndex(x => x.Contains(LastFourCode));

            // ch:获取选择的设备信息 | en:Get selected device information
            MyCamera.MV_CC_DEVICE_INFO device =
                (MyCamera.MV_CC_DEVICE_INFO)Marshal.PtrToStructure(m_stDeviceList.pDeviceInfo[id],
                                                              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();
                ShowErrorMsg("Device open fail!", nRet);
                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)
                    {
                        ShowErrorMsg("Set Packet Size failed!", nRet);
                    }
                }
                else
                {
                    ShowErrorMsg("Get Packet Size failed!", nPacketSize);
                }
            }

            // 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);

            //bnGetParam_Click(null, null);// ch:获取参数 | en:Get parameters
        }

        /// <summary>
        /// 开始采集
        /// </summary>
        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();
                ShowErrorMsg("Start Grabbing Fail!", nRet);
                return;
            }
        }

        /// <summary>
        /// 停止采集
        /// </summary>
        public void StopGrab()
        {
            // ch:标志位设为false | en:Set flag bit false
            m_bGrabbing = false;
            m_hReceiveThread?.Join();
            // ch:停止采集 | en:Stop Grabbing
            int nRet = m_MyCamera.MV_CC_StopGrabbing_NET();
            if (nRet != MyCamera.MV_OK)
            {
                ShowErrorMsg("Stop Grabbing Fail!", nRet);
            }
        }

        public void StartTriggerMode()
        {
            // ch:打开触发模式 | en:Open Trigger Mode
            m_MyCamera.MV_CC_SetEnumValue_NET("TriggerMode", (uint)MyCamera.MV_CAM_TRIGGER_MODE.MV_TRIGGER_MODE_ON);

            // ch:触发源选择:0 - Line0; | en:Trigger source select:0 - Line0;
            //           1 - Line1;
            //           2 - Line2;
            //           3 - Line3;
            //           4 - Counter;
            //           7 - Software;
            m_MyCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_LINE0);
            m_MyCamera.MV_CC_SetEnumValue_NET("TriggerSource", (uint)MyCamera.MV_CAM_TRIGGER_SOURCE.MV_TRIGGER_SOURCE_SOFTWARE);
        }

        /// <summary>
        /// 软触发
        /// </summary>
        public void TriggerExec()
        {
            // ch:触发命令 | en:Trigger command
            int nRet = m_MyCamera.MV_CC_SetCommandValue_NET("TriggerSoftware");
            if (MyCamera.MV_OK != nRet)
            {
                ShowErrorMsg("Trigger Software Fail!", nRet);
            }
        }

        public Bitmap GetPicture()
        {
            if (false == m_bGrabbing)
            {
                ShowErrorMsg("Not Start Grabbing", 0);
                return null;
            }

            if (RemoveCustomPixelFormats(m_stFrameInfo.enPixelType))
            {
                ShowErrorMsg("Not Support!", 0);
                return null;
            }

            //MyCamera.MV_SAVE_IMG_TO_FILE_PARAM stSaveFileParam = new MyCamera.MV_SAVE_IMG_TO_FILE_PARAM();
            //while (image == null)
            //{
            //    Thread.Sleep(100);
            //}
            //return image;
            lock (BufForDriverLock)
            {
                Bitmap imagen = Mono8ToBitmap(m_stFrameInfo.nWidth, m_stFrameInfo.nHeight, m_BufForDriver);//获取相机图片
                SaveImage(imagen);
                return imagen;
            }
        }

        public Bitmap GetPicturen()
        {
            MyCamera.MV_FRAME_OUT stFrameInfo = new MyCamera.MV_FRAME_OUT();
            MyCamera.MV_DISPLAY_FRAME_INFO stDisplayInfo = new MyCamera.MV_DISPLAY_FRAME_INFO();
            int nRet = MyCamera.MV_OK;
            int times = 0;
            while (true)
            {
                times++;
                if (times > 5)
                {
                    return null;
                }
                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 null;
                            }
                            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;
                    }
                    //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);

                    Bitmap image = Mono8ToBitmap(stFrameInfo.stFrameInfo.nWidth, stFrameInfo.stFrameInfo.nHeight, stFrameInfo.pBufAddr);//获取相机图片
                                                                                                                                        //SaveImage(image);
                    return image;
                }
                else
                {
                    if (bnTriggerMode)
                    {
                        Thread.Sleep(5);
                    }
                }
            }
            return null;
        }

        //设置曝光
        public void SetParam(int para)
        {
            m_MyCamera.MV_CC_SetEnumValue_NET("ExposureAuto", 0);
            int nRet = m_MyCamera.MV_CC_SetFloatValue_NET("ExposureTime", para);//曝光
            if (nRet != MyCamera.MV_OK)
            {
                ShowErrorMsg("Set Exposure Time Fail!", nRet);
            }

            m_MyCamera.MV_CC_SetEnumValue_NET("GainAuto", 0);
            nRet = m_MyCamera.MV_CC_SetFloatValue_NET("Gain", 0);//自动增益
            if (nRet != MyCamera.MV_OK)
            {
                ShowErrorMsg("Set Gain Fail!", nRet);
            }

            nRet = m_MyCamera.MV_CC_SetFloatValue_NET("AcquisitionFrameRate", 10);//采集帧率
            if (nRet != MyCamera.MV_OK)
            {
                ShowErrorMsg("Set Frame Rate Fail!", nRet);
            }
        }

        private Bitmap image = null;

        public void ReceiveThreadProcess()
        {
            MyCamera.MV_FRAME_OUT stFrameInfo = new MyCamera.MV_FRAME_OUT();
            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;
                    }
                    //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);

                    Bitmap image = Mono8ToBitmap(stFrameInfo.stFrameInfo.nWidth, stFrameInfo.stFrameInfo.nHeight, stFrameInfo.pBufAddr);//获取相机图片
                    //SaveImage(image);
                }
                else
                {
                    if (bnTriggerMode)
                    {
                        Thread.Sleep(5);
                    }
                }
            }
        }

        // ch:去除自定义的像素格式 | en:Remove custom pixel formats
        public bool RemoveCustomPixelFormats(MyCamera.MvGvspPixelType enPixelFormat)
        {
            Int32 nResult = ((int)enPixelFormat) & (unchecked((Int32)0x80000000));
            if (0x80000000 == nResult)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void ShowErrorMsg(string csMessage, int nErrorNum)
        {
            string errorMsg;
            if (nErrorNum == 0)
            {
                errorMsg = csMessage;
            }
            else
            {
                errorMsg = csMessage + ": Error =" + String.Format("{0:X}", nErrorNum);
            }

            switch (nErrorNum)
            {
                case MyCamera.MV_E_HANDLE: errorMsg += " Error or invalid handle "; break;
                case MyCamera.MV_E_SUPPORT: errorMsg += " Not supported function "; break;
                case MyCamera.MV_E_BUFOVER: errorMsg += " Cache is full "; break;
                case MyCamera.MV_E_CALLORDER: errorMsg += " Function calling order error "; break;
                case MyCamera.MV_E_PARAMETER: errorMsg += " Incorrect parameter "; break;
                case MyCamera.MV_E_RESOURCE: errorMsg += " Applying resource failed "; break;
                case MyCamera.MV_E_NODATA: errorMsg += " No data "; break;
                case MyCamera.MV_E_PRECONDITION: errorMsg += " Precondition error, or running environment changed "; break;
                case MyCamera.MV_E_VERSION: errorMsg += " Version mismatches "; break;
                case MyCamera.MV_E_NOENOUGH_BUF: errorMsg += " Insufficient memory "; break;
                case MyCamera.MV_E_UNKNOW: errorMsg += " Unknown error "; break;
                case MyCamera.MV_E_GC_GENERIC: errorMsg += " General error "; break;
                case MyCamera.MV_E_GC_ACCESS: errorMsg += " Node accessing condition error "; break;
                case MyCamera.MV_E_ACCESS_DENIED: errorMsg += " No permission "; break;
                case MyCamera.MV_E_BUSY: errorMsg += " Device is busy, or network disconnected "; break;
                case MyCamera.MV_E_NETER: errorMsg += " Network error "; break;
            }

            MessageBox.Show(errorMsg, "PROMPT");
        }

        public Bitmap Mono8ToBitmap(int Width, int Height, IntPtr pointer)
        {
            try
            {
                //创建一个Bitmap对象，宽度、高度、宽度乘以1（无符号位），像素格式为8位索引，指针参数为输入参数
                Bitmap ig = new Bitmap(Width, Height, Width * 1, PixelFormat.Format8bppIndexed, pointer);
                //获取Bitmap的调色板
                ColorPalette cp = ig.Palette;
                //遍历256次，为调色板中的每个颜色项赋值
                for (int i = 0; i < 256; i++)
                {
                    cp.Entries[i] = Color.FromArgb(i, i, i);
                }
                //将调色板应用到Bitmap对象
                ig.Palette = cp;
                //将Bitmap保存为Assets/22222.jpg
                //bmp.Save("Assets/22222.jpg");
                return ig;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public string SaveImage(Bitmap image, bool getpath = false)
        {
            string time = System.DateTime.Now.ToString("yyyy/MM/dd").Replace(":", "-").Replace("/", "-");

            //包装箱文件夹不存在创建
            string xhpath = Application.StartupPath + @"\pic" + "\\" + time + "\\";
            //文件夹不存在创建
            if (!Directory.Exists(xhpath))
            {
                Directory.CreateDirectory(xhpath);
            }
            string name = System.DateTime.Now.ToString("yyyy-MM-dd") + " " + System.DateTime.Now.TimeOfDay.ToString().Replace(":", "-").Replace(".", "-");

            image.Save("pic/" + time + "/" + name + ".jpg");

            return name;
        }
    }
}

标签
#c# #数码相机 #开发语言
C#之调用海康工业相机SDK采集图像并在Halcon窗口中显示
Kevin_Sun777的博客
10-22 2万+
C#之调用海康工业相机SDK采集图像并在Halcon窗口中显示 最近做项目需要对海康相机进行二次开发，现将所学进行整理。 开发环境 VS2012+C#（32位） Halcon12 引用动态链接库 引用Halcon动态链接库（halcondotnet.dll） 引用海康相机动态链接库（MvCameraControl.Net.dll）这个文件在MVS安装目录下MVS\Development\DotNet中，如果你是32位的开发环境就选择win32文件夹下的，如果是64位就选择win64文件夹下...
工业互联网（二）——VS(C#)调用海康工业相机SDK采集图像及基本功能设定
lvjiyang的博客
06-29 8674
海康威视MV-CA060-11 GM工业相机首次安装与MVS客户端操作 https://blog.csdn.net/u014779536/article/details/106577273/?ops_request_misc=&request_id=&biz_id=102&utm_term=%E6%B5%B7%E5%BA%B7mvs%E7%9B%B8%E6%9C%BA%E8%BD%AF%E4%BB%B6%E6%95%99%E7%A8%8B&utm_medium=distrib
海康工业相机SDK C#开发示例程序.zip
12-25
海康工业相机SDK C#开发示例程序，包括软件触发，硬件触发，单帧采集，实时采集
C# WinForm海康相机对接教程
IT技术类博客
05-09 2003
以下是基于C#和WinForm对接海康相机的操作教程，结合了官方SDK使用和实际开发中的关键注意事项，帮助开发者快速实现相机连接、图像采集与控制功能。
海康相机SDK二次开发与Qt混合编程代码和说明手册
07-26
在海康相机SDK的基础上进行海康相机的二次开发，其次就是在Qt上实现这个相机，其中涉及到与Qt的混合编程，数据转换
关于C#中的指针拷贝
qq_37189288的博客
12-05 2989
1、RtlCopyMemory与RtlMoveMemory 这两个函数是内核函数api，对应Win32 API是CopyMemory和MoveMemory。都能实现内存块的复制，两者的区别在于CopyMemory是非重叠内存区域的复制，MoveMemory可以不考虑是否重叠，都可以安全复制。 2、Marshal类 Marshal.copy()方法用来在托管对象（数组）和非托管对象（IntPtr）之间进行内容的复制。但是它只能实现数组拷贝
C#里使用CopyMemory
hxp42的专栏
10-14 6713
<br />Socket接收到的byte []要转换成自定义的struct / 自定义Struct转换成byte []都相当麻烦<br />用循环去转换太浪费时间了……于是想到用CopyMemory，Google一圈终于搞定<br />下面的代码是在Snippet Compiler里编译通过的<br />C#代码<br />#region Imports    <br />using System;    <br />using System.IO;    <br />using System.Net;  
(54) C# 调用 kernel32.dll
ainixi7099的博客
09-04 1124
https://www.cnblogs.com/cwy173/archive/2010/10/02/1841321.html Kernel32 API AddAtom 向本地原子表添加一个字符串 AllocConsole 为当前进程分配一个新控制台 AreFileApisANSI 确定一个WIN32文件函数集是否在使用ANSI或OEM字符集代码...
HALCON联合C#检测表面缺陷——海康相机SDK开发
奔跑的郑的博客
12-13 3056
...
海康相机基础控制类 热插拔等功能
最新发布
weixin_54987134的博客
09-29 769
海康相机的基本控制，包含热链接和必要的控制。
C#快速调用海康威视工业相机的SDK拍照获取图片
热门推荐
zls365365的博客
12-13 2万+
本文章开头会先讲一下如何找到SDK包和demo，功能的实现我会直接用平时常用的DLL以及根据海康威视给的demo封装好的常用功能类，这些都会分享到文末的链接中。注：halcon虽然有读取相...
C# 与 Halcon 联合编程连接海康威视相机
weixin_44713908的博客
10-07 6720
以下内容来自海康威视SDK： #region 海康威视 全局 MyCamera.MV_CC_DEVICE_INFO_LIST m_pDeviceList; private MyCamera m_pMyCamera; bool m_bGrabbing; byte[] m_pBufForSaveImage = new ...
【海康威视Sionyx三个摄像头C#画面实现】
vor234的博客
02-24 2159
🥳🥳🥳现在，通过本文的介绍，我们成功实现了使用C#编程语言显示海康威视海康威视网络和Sionyx USB夜视三个摄像头，并实时显示摄像头的视频流。希望本文对您有所帮助！我们将使用海康威视的iVMS-4200软件进行摄像头的初始化和配置，并通过C#编写的上位机程序来显示摄像头的实时画面。它使各级海员都可以在没有白光或昂贵的热像仪的情况下，在没有月亮的星光下轻松发现障碍物和碎片，从而安全航行，避免碰撞，并最大限度地延长水上时间。如果想修改设备ip，双击设备的iPv4信息，按要求修改，输入摄像头密码，即可更
海康威视摄像机SDK的使用
zhouwensmile的博客
11-07 2093
文章未经允许，不可转载海康威视提供的SDK,支持C++、Java、C#，但是就是不支持Python，调用SDK并不是件很愉快的事情。毕竟和图像相关的程序，Python编写起来更加方便。如果不特定选择海康威视这个品牌，大华摄像机是支持Python，而且还支持go，第一次看到的时候，我还是吃了一惊，心想厉害呀！解码yuv编写类调用海康威视相机void *redis多线程制作Python的海康威视库（不是重点）
gige相机二次开发_海康工业相机 SDK 二次开发示例程序说明（C#版）
weixin_34577766的博客
12-30 6711
这个是海康相机官方的文档，勇哥放上来是为了方便查阅。【摘要】本文档主要介绍了使用工业相机SDK(Software Development Kit)开发C#程序方法及过程。在SDK开发包目录下，提供了21个C#示例程序，其中Form程序6个，分别为BasicDemo、ReconnectDemo、SetIODemo、ForceIpDemo、MultipleDemo、BasedOnGenTL；控制台程序...
通过海康萤石API控制家里相机的云台及抓图
Hi20240217的博客
05-28 2002
本文介绍如何通过海康萤石API实现家用摄像头的远程控制功能。首先需要在萤石开放平台注册开发者账号，获取AppKey和Secret认证信息，并绑定目标设备。文中详细展示了Python代码实现，包括获取accessToken认证、查询设备列表、控制云台移动（支持8个方向调节）以及定时抓拍图片等功能，并提供完整的HTTP请求封装方法和错误处理机制。通过API集成，用户可摆脱原生App限制，实现更加灵活智能的家居监控方案，例如云台自动转向后抓拍指定区域图像。所有代码片段均附带关键参数说明，适合智能家居爱好者或开发者
C#开发海康相机上位机应用：SDK实战与技术解析
这里只有干货：从 Modbus 通信到 MES 对接，从 YOLO 训练到工控机部署，带你搞定工业软件开发全流程。
06-19 1248
本文详细介绍了使用C#开发海康威视相机上位机应用的完整流程。主要内容包括：1) 海康SDK的概述及核心功能模块；2) 开发环境搭建与SDK配置；3) 基本操作如设备连接、视频流获取与错误处理；4) 进阶功能实现包括截图和录像。通过调用海康SDK的API接口，开发者可以快速构建功能完善的监控系统，实现设备管理、实时监控和数据处理等功能。文章提供了关键代码示例，帮助开发人员掌握海康相机SDK的集成与应用开发技术。
利用python加opencv与海康工业相机交互。（得到供opencv处理的数据）
bookshu6的博客
01-18 1万+
文章目录前言一、准备工作二、c#调用1.引入库3、python调用4 完整代码总结题外话 前言 因为项目的原因，笔者需要利用程序来实时调用海康工业相机，而不是简单的利用海康的驱动来调用相机。 在经历了反复的踩坑填坑之后，笔者总结了利用c#和python调用海康相机的两种方法 一、准备工作 无论是用c#还是python，都是要通过海康的SDK来进行二次开发的。海康的SDK相当于一个库，里面有各种用于海康相机的函数，这些函数被封装成供各大编程语言使用。所以，要想利用python或者c#与海康进行实时交互，就
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值