代码先锋网 代码片段及技术文章聚合

添加ThridLibray.dll，halcondotnet.dll 引用即可

动态链接库 密码：4k2d

using HalconDotNet;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ThridLibray;

namespace FormFrame.SDK
{
    public struct Camera
    {
        public string Name;
        public string Key;
        public string Model;
        public int Index;
    }
    public class DaHuaSDK
    {
        private IDevice m_dev;
        private List<IGrabbedRawData> m_frameList = new List<IGrabbedRawData>();        /* 图像缓存列表 */
        private Thread renderThread = null;         /* 显示线程  */
        private bool m_bShowLoop = true;            /* 线程控制变量 */
        private Mutex m_mutex = new Mutex();        /* 锁，保证多线程安全 */
        private const int DEFAULT_INTERVAL = 40;
        private Stopwatch m_stopWatch = new Stopwatch();    /* 时间统计器 */
        private HObject ho_image;
        /// <summary>
        /// 图像处理自定义委托
        /// </summary>
        /// <param name="HImage">halcon图像变量</param>
        public delegate void delegateProcessHImage( HObject hImage );
        /// <summary>
        /// 图像处理委托事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public event delegateProcessHImage eventProcessImage;


        public delegate void delegateError( string message );
        public delegate void delegateInfo( string message );

        public event delegateError Eventerror;//错误
        public event delegateError Eventinfo;//提示

        /// <summary>
        /// 获取相机列表
        /// </summary>
        /// <returns></returns>
        public List<Camera> CameraList()
        {
            List<Camera> cameraList = new List<Camera>();
            List<IDeviceInfo> li = Enumerator.EnumerateDevices();
            for ( int i = 0; i < li.Count; i++ )
            {
                cameraList.Add( new Camera() { Key = li[i].Key, Name = li[i].Name, Model = li[i].Model, Index = li[i].Index } );
            }
            return cameraList;
        }

        /// <summary>
        /// 相机名称
        /// </summary>
        public string Name;
        /// <summary>
        /// 初始化相机
        /// </summary>
        /// <param name="cameraName"></param>
        public DaHuaSDK( string cameraName )
        {
            List<IDeviceInfo> li = Enumerator.EnumerateDevices();
            bool flag = false;
            for ( int i = 0; i < li.Count; i++ )
            {
                if ( li[i].Name == cameraName )
                {
                    if ( Eventinfo != null )
                    {
                        Eventinfo( DateTime.Now.ToString() + "    已找到相机。" );
                    }
                    m_dev = Enumerator.GetDeviceByIndex( i );
                    Name = cameraName;
                    flag = true;
                    break;
                }
            }
            if ( !flag )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    未找到相机！" );
                }
                throw new Exception( DateTime.Now.ToString() + "    未找到相机！" );
            }
        }
        /// <summary>
        /// 打开相机
        /// </summary>
        /// <returns></returns>
        public bool Open()
        {
            bool state = m_dev.Open();
            if ( state )
            {
                if ( Eventinfo != null )
                {
                    Eventinfo( DateTime.Now.ToString() + "    相机已打开。" );
                }
                m_dev.CameraOpened += OnCameraOpen;
                m_dev.ConnectionLost += OnConnectLoss;
                m_dev.CameraClosed += OnCameraClose;
                /* 打开Software Trigger */
                m_dev.TriggerSet.Open( TriggerSourceEnum.Software );

                using ( IEnumParameter p = m_dev.ParameterCollection[ParametrizeNameSet.ImagePixelFormat] )
                {
                    p.SetValue( "Mono8" );
                }
                /* 设置缓存个数为8（默认值为16） */
                m_dev.StreamGrabber.SetBufferCount( 8 );
                /* ***流回调事件 */
                m_dev.StreamGrabber.ImageGrabbed += OnImageGrabbed;

                renderThread = new Thread( new ThreadStart( ShowThread ) ) { IsBackground = true };
                renderThread.Start();

                /* 开启码流 */
                if ( !m_dev.GrabUsingGrabLoopThread() )
                {
                    if ( Eventerror != null )
                    {
                        Eventerror( DateTime.Now.ToString() + "    流码开启失败。" );
                    }
                    return false;
                }
                if ( Eventinfo != null )
                {
                    Eventinfo( DateTime.Now.ToString() + "    流码已开启。" );
                }
            }
            return state;
        }
        /// <summary>
        /// 关闭相机
        /// </summary>
        /// <returns></returns>
        public bool Close()
        {
            try
            {
                if ( m_dev != null )
                {
                    m_dev.StreamGrabber.ImageGrabbed -= OnImageGrabbed;         /* 反注册回调 */
                    m_dev.ShutdownGrab();                                       /* 停止码流 */
                    m_dev.Close();                                              /* 关闭相机 */
                    if ( Eventinfo != null )
                    {
                        Eventinfo( DateTime.Now.ToString() + "    相机关闭成功。" );
                    }
                    return m_dev.Close();
                }
            }
            catch ( Exception e )
            {

                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return true;
        }
        /// <summary>
        /// 相机状态
        /// </summary>
        /// <returns></returns>
        public bool IsOpen()
        {
            return m_dev.IsOpen;
        }
        private bool isTimeToDisplay()
        {
            m_stopWatch.Stop();
            long m_lDisplayInterval = m_stopWatch.ElapsedMilliseconds;
            if ( m_lDisplayInterval <= DEFAULT_INTERVAL )
            {
                m_stopWatch.Start();
                return false;
            }
            else
            {
                m_stopWatch.Reset();
                m_stopWatch.Start();
                return true;
            }
        }
        private void ShowThread()
        {
            while ( m_bShowLoop )
            {
                if ( m_frameList.Count == 0 )
                {
                    Thread.Sleep( 10 );
                    continue;
                }

                /* 图像队列取最新帧 */
                m_mutex.WaitOne();
                IGrabbedRawData frame = m_frameList.ElementAt(m_frameList.Count - 1);
                m_frameList.Clear();
                m_mutex.ReleaseMutex();

                /* 主动调用回收垃圾 */
                GC.Collect();

                /* 控制显示最高帧率为25FPS */
                if ( false == isTimeToDisplay() )
                {
                    continue;
                }

                try
                {
                    /* 图像转码成bitmap图像 */
                    var bitmap = frame.ToBitmap(false);
                    BitmapToHImage( bitmap );
                    if ( eventProcessImage != null )
                    {
                        eventProcessImage( ho_image );
                    }
                }
                catch ( Exception exception )
                {
                    Catcher.Show( exception );
                }
            }
        }
        /// <summary>
        /// Bitmap格式图片转Hobject格式
        /// </summary>
        /// <param name="SrcImage"></param>
        /// <returns></returns>
        private HObject BitmapToHImage( Bitmap SrcImage )
        {

            HOperatorSet.GenEmptyObj( out ho_image );

            Point po = new Point(0, 0);
            Size so = new Size(SrcImage.Width, SrcImage.Height);//template.Width, template.Height
            Rectangle ro = new Rectangle(po, so);

            Bitmap DstImage = new Bitmap(SrcImage.Width, SrcImage.Height, PixelFormat.Format8bppIndexed);
            DstImage = SrcImage.Clone( ro, PixelFormat.Format8bppIndexed );

            int width = DstImage.Width;
            int height = DstImage.Height;

            Rectangle rect = new Rectangle(0, 0, width, height);
            System.Drawing.Imaging.BitmapData dstBmpData =
                DstImage.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);//pImage.PixelFormat
            int PixelSize = Bitmap.GetPixelFormatSize(dstBmpData.PixelFormat) / 8;
            int stride = dstBmpData.Stride;


            unsafe
            {
                int count = height * width;
                byte[] data = new byte[count];
                byte* bptr = (byte*)dstBmpData.Scan0;
                fixed ( byte* pData = data )
                {
                    for ( int i = 0; i < height; i++ )
                        for ( int j = 0; j < width; j++ )
                        {
                            data[i * width + j] = bptr[i * stride + j];
                        }
                    HOperatorSet.GenImage1( out ho_image, "byte", width, height, new IntPtr( pData ) );
                }
            }

            DstImage.UnlockBits( dstBmpData );
            return ho_image;
        }
        /// <summary>
        /// Bitmap格式图片转Hobject格式
        /// </summary>
        /// <param name="SrcImage"></param>
        /// <returns></returns>
        public HObject Bitmap2Hobject( Bitmap bitmap )
        {
            Rectangle rectangle = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
            BitmapData bitmapData = bitmap.LockBits(rectangle, ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);
            IntPtr intPtr = bitmapData.Scan0;
            HOperatorSet.GenEmptyObj( out ho_image );

            HOperatorSet.GenEmptyObj( out ho_image );

            ho_image.Dispose();
            HOperatorSet.GenImageInterleaved( out ho_image, intPtr, "bgrx", bitmap.Width, bitmap.Height, -1, "byte", 0, 0, 0, 0, -1, 0 );
            bitmap.UnlockBits( bitmapData );

            return ho_image;
        }
        /// <summary>
        /// 设置曝光时间
        /// </summary>
        /// <param name="value"></param>
        public void SetExposureTime( int value )
        {
            try
            {
                using ( IFloatParameter p = m_dev.ParameterCollection[ParametrizeNameSet.ExposureTime] )
                {

                    p.SetValue( value );
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
        }
        /// <summary>
        /// 获取当前相机曝光值
        /// </summary>
        /// <returns></returns>
        public double GetExposureTime()
        {
            try
            {

                using ( IFloatParameter p = m_dev.ParameterCollection[new FloatName( "ExposureTime" )] )
                {

                    return p.GetValue();
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return 0;
        }
        /// <summary>
        /// 获取所有像素格式
        /// </summary>
        /// <returns></returns>
        public List<string> GetAllPixelFormatList()
        {
            try
            {
                using ( IEnumParameter p = m_dev.ParameterCollection[new EnumName( "PixelFormat" )] )
                {
                    Trace.WriteLine( string.Format( "PixelFormat value: {0}", p.GetValue() ) );
                    List<string> list = new List<string>();
                    list = p.GetAllValues();
                    return list;
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return new List<string>();
        }
        /// <summary>
        /// 获取当前像素格式
        /// </summary>
        /// <returns></returns>
        public string GetPixelFormat()
        {
            try
            {
                using ( IEnumParameter p = m_dev.ParameterCollection[new EnumName( "PixelFormat" )] )
                {
                    Trace.WriteLine( string.Format( "PixelFormat value: {0}", p.GetValue() ) );
                    return p.GetValue();
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return "";
        }
        /// <summary>
        /// 设置像素格式
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool SetPixelFormat( string value )
        {
            try
            {
                using ( IEnumParameter p = m_dev.ParameterCollection[ParametrizeNameSet.ImagePixelFormat] )
                {
                    return p.SetValue( value );
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return false;
        }
        /// <summary>
        /// 设置增益
        /// </summary>
        /// <param name="value"></param>
        public void SetGainRaw( int value )
        {
            try
            {
                using ( IFloatParameter p = m_dev.ParameterCollection[ParametrizeNameSet.GainRaw] )
                {
                    p.SetValue( (double)value );
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }

        }
        /// <summary>
        /// 设置缓存个数为
        /// </summary>
        public void SetBufferCount( int value )
        {
            try
            {


                /* 设置缓存个数为8（默认值为16） */
                m_dev.StreamGrabber.SetBufferCount( value );
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }

        }
        /// <summary>
        /// 开始连续采集
        /// </summary>
        /// <returns></returns>
        public bool StartCollectCapture()
        {
            try
            {
                m_dev.ShutdownGrab();
                m_dev.TriggerSet.Close();
                return m_dev.GrabUsingGrabLoopThread();
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return false;
        }
        /// <summary>
        /// 停止连续采集
        /// </summary>
        /// <returns></returns>
        public bool StopCollectCapture()
        {
            try
            {
                m_dev.ShutdownGrab();
                m_dev.TriggerSet.Open( TriggerSourceEnum.Software );
                return m_dev.GrabUsingGrabLoopThread();
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return false;
        }
        /// <summary>
        /// 拍摄单张图像
        /// </summary>
        /// <returns></returns>
        public bool GrabImage()
        {
            try
            {
                m_dev.TriggerSet.Open( TriggerSourceEnum.Software );
                Thread.Sleep( 10 );
                bool flag =  m_dev.ExecuteSoftwareTrigger();
                m_stopWatch.Restart();
                return flag;
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }
            return false;
        }
        /// <summary>
        /// 设置触发模式，0为软触发，1为外触发
        /// </summary>
        public void TriggerSource( int num )
        {
            try
            {
                if ( num == 0 )
                {
                    m_dev.TriggerSet.Open( TriggerSourceEnum.Software );
                }
                else if ( num == 1 )
                {
                    m_dev.TriggerSet.Open( TriggerSourceEnum.Line1 );
                }
            }
            catch ( Exception e )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + e.Message );
                }
            }

        }
        /// <summary>
        /// 相机关闭回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnCameraClose( object sender, EventArgs e )
        {

        }
        /// <summary>
        /// 相机丢失回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnConnectLoss( object sender, EventArgs e )
        {
            m_dev.ShutdownGrab();
            m_dev.Dispose();
            m_dev = null;
            System.Windows.Forms.MessageBox.Show( "相机：" + Name + "已掉线，请检查。" );
        }
        /// <summary>
        /// 相机打开回调
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnCameraOpen( object sender, EventArgs e )
        {

        }
        /// <summary>
        /// ***流回调事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnImageGrabbed( object sender, GrabbedEventArgs e )
        {
            try
            {
                m_mutex.WaitOne();
                m_frameList.Add( e.GrabResult.Clone() );
                m_mutex.ReleaseMutex();
            }
            catch ( Exception ex )
            {
                if ( Eventerror != null )
                {
                    Eventerror( DateTime.Now.ToString() + "    " + ex.Message );
                }
            }
        }

    }
}