using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
using HalconDotNet;
using FlyCapture2Managed;

namespace PointGreyAndHalcon
{
    public delegate void GrabImageDoneDelegate(string recData,HImage recImage);

    public class PointGreyAndHalcon
    {
        #region 定义
        ManagedBusManager busMgr = new ManagedBusManager();
        //CameraInfo[] camInfos = ManagedBusManager.DiscoverGigECameras();
        int camNum;
        ManagedPGRGuid guid;
        ManagedGigECamera cam;

        public HImage image = new HImage();
        public event GrabImageDoneDelegate GrabImageDone;
        public string SerialNo;

        HImage tmpImage = new HImage();
        bool isCameraOpen = false;
        //bool isRightCameraOpen = false;
        #endregion

        public  PointGreyAndHalcon()
        {
            //camNum = camInfos.Length;
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="index">编号</param>
        public void OpenCamera(int index)
        {
            try
            {
                guid = busMgr.GetCameraFromIndex((uint)index);
                cam = new ManagedGigECamera();
                cam.Connect(guid);
                cam.StartCapture();
                isCameraOpen = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("相机" + index.ToString() + "打开失败");
                
            }
        }

        /// <summary>
        /// 打开相机
        /// </summary>
        /// <param name="serialnumber">序列号</param>
        public bool OpenCamera(uint serialnumber)
        {
            try
            {
                guid = busMgr.GetCameraFromSerialNumber(serialnumber);
                cam = new ManagedGigECamera();
                cam.Connect(guid);

                cam.WriteRegister(0x610,0x00000000);//控制相机上电
                System.Threading.Thread.Sleep(100);
                cam.WriteRegister(0x610, 0x80000000);//控制相机下电

                cam.StartCapture();
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show("相机" + serialnumber.ToString() + "打开失败");
                return false;
            }
        }

        ///// <summary>
        ///// 打开相机
        ///// </summary>
        ///// <param name="serialnumber">序列号</param>
        //public void OpenCamera_test(uint serialnumber)
        //{
        //    try
        //    {
        //        guid = busMgr.GetCameraFromSerialNumber(serialnumber);
        //        cam = new ManagedGigECamera();
        //        cam.Connect(guid);
        //        cam.StartCapture(Test);
        //    }
        //    catch (Exception ex)
        //    {
        //        MessageBox.Show("相机" + serialnumber.ToString() + "打开失败");
        //    }
        //}

        private void Test(ManagedImage image)
        {
            lock (GetMutexLock())
            {
                SerialNo = "";
                try
                {
                    //ManagedImage rawImage = new ManagedImage();

                    // Retrieve an image
                    //cam.RetrieveBuffer(rawImage);
                    
                    // Create a converted image
                    ManagedImage convertedImage = new ManagedImage();

                    // Convert the raw image
                    image.Convert(FlyCapture2Managed.PixelFormat.PixelFormatMono8, convertedImage);

                    //converterImage to HImage
                    Bitmap tmpBmp = convertedImage.bitmap;
                    BitmapData tmpBitmapData = tmpBmp.LockBits(new Rectangle(0, 0, tmpBmp.Width, tmpBmp.Height), ImageLockMode.ReadOnly,
                        System.Drawing.Imaging.PixelFormat.Format8bppIndexed);

                    tmpImage.GenImage1("byte", tmpBmp.Width, tmpBmp.Height, tmpBitmapData.Scan0);

                    if (GrabImageDone != null)
                    {
                        GrabImageDone("GrabSuccess", tmpImage);
                    }

                    tmpBmp.UnlockBits(tmpBitmapData);
                    image.Dispose();
                    convertedImage.Dispose();
                    tmpBmp.Dispose();
                }
                catch (Exception ex)
                {
                    if (GrabImageDone != null)
                    {
                        GrabImageDone("GrabFail", tmpImage);
                    }
                }
            }
        }

        /// <summary>
        /// 关闭相机
        /// </summary>
        public void CloseCamera()
        {
            cam.StopCapture();
        }

        /// <summary>
        /// 采图
        /// </summary>
        public void GrabImage(string sn)
        {
            lock (GetMutexLock())
            {
                SerialNo = sn;
                try
                {
                    ManagedImage rawImage = new ManagedImage();

                    // Retrieve an image
                    cam.RetrieveBuffer(rawImage);

                    // Create a converted image
                    ManagedImage convertedImage = new ManagedImage();

                    // Convert the raw image
                    rawImage.Convert(FlyCapture2Managed.PixelFormat.PixelFormatMono8, convertedImage);

                    //converterImage to HImage
                    Bitmap tmpBmp = convertedImage.bitmap;
                    BitmapData tmpBitmapData = tmpBmp.LockBits(new Rectangle(0, 0, tmpBmp.Width, tmpBmp.Height), ImageLockMode.ReadOnly,
                        System.Drawing.Imaging.PixelFormat.Format8bppIndexed);

                    tmpImage.GenImage1("byte", tmpBmp.Width, tmpBmp.Height, tmpBitmapData.Scan0);
                    image.Dispose();
                    image = tmpImage.CopyImage();
                    if (GrabImageDone != null)
                    {
                        GrabImageDone("GrabSuccess", tmpImage);
                    }

                    tmpBmp.UnlockBits(tmpBitmapData);
                    rawImage.Dispose();
                    convertedImage.Dispose();
                    tmpBmp.Dispose();
                }
                catch (Exception ex)
                {
                    if (GrabImageDone != null)
                    {
                        GrabImageDone("GrabFail", tmpImage);
                    }
                }
            }
        }

        /// <summary>
        /// 采彩色图
        /// </summary>
        public void GrabColorImage(string sn)
        {
            SerialNo = sn;
            try
            {
                ManagedImage rawImage = new ManagedImage();

                // Retrieve an image
                cam.RetrieveBuffer(rawImage);

                // Create a converted image
                ManagedImage convertedImage = new ManagedImage();

                // Convert the raw image
                rawImage.Convert(FlyCapture2Managed.PixelFormat.PixelFormatBgr, convertedImage);

                //converterImage to HImage
                Bitmap tmpBmp = convertedImage.bitmap;
                Rectangle rect = new Rectangle(0, 0, tmpBmp.Width, tmpBmp.Height);
                BitmapData tmpBitmapData = tmpBmp.LockBits(rect, ImageLockMode.ReadOnly,
                    System.Drawing.Imaging.PixelFormat.Format24bppRgb);

                #region 将RGB分离开来
                //创建新的彩色的bitmap
                Bitmap redBitmap = new Bitmap(tmpBmp.Width, tmpBmp.Height);
                Bitmap greenBitmap = new Bitmap(tmpBmp.Width, tmpBmp.Height);
                Bitmap blueBitmap = new Bitmap(tmpBmp.Width, tmpBmp.Height);
                //创建新的彩色的数据容器
                BitmapData redBmData = redBitmap.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
                BitmapData greenBmData = greenBitmap.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
                BitmapData blueBmData = blueBitmap.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format8bppIndexed);
                //将Bitmap对象的信息存放到byte数组中
                int tmp_bytes = tmpBitmapData.Stride * tmpBmp.Height;
                int red_bytes = redBmData.Stride * tmpBmp.Height;
                int green_bytes = greenBmData.Stride * tmpBmp.Height;
                int blue_bytes = blueBmData.Stride * tmpBmp.Height;
                byte[] tmpValues = new byte[tmp_bytes];
                byte[] redValues = new byte[red_bytes];
                byte[] greenValues = new byte[green_bytes];
                byte[] blueValues = new byte[blue_bytes];
                //复制GRB信息到byte数组
                System.Runtime.InteropServices.Marshal.Copy(tmpBitmapData.Scan0, tmpValues, 0, tmp_bytes);
                System.Runtime.InteropServices.Marshal.Copy(redBmData.Scan0, redValues, 0, red_bytes);
                System.Runtime.InteropServices.Marshal.Copy(greenBmData.Scan0, greenValues, 0, green_bytes);
                System.Runtime.InteropServices.Marshal.Copy(blueBmData.Scan0, blueValues, 0, blue_bytes);

                //将彩色信息分别存储到RGB数组中
                for (int i = 0; i < tmpBmp.Height; i++)
                {
                    for (int j = 0; j < tmpBmp.Width; j++)
                    {
                        int k = 3 * j;
                        redValues[i * redBmData.Stride + j] = tmpValues[i * tmpBitmapData.Stride + k + 2];
                        greenValues[i * blueBmData.Stride + j] = tmpValues[i * tmpBitmapData.Stride + k + 1];
                        blueValues[i * greenBmData.Stride + j] = tmpValues[i * tmpBitmapData.Stride + k];
                    }
                }

                //再将数组信息复制到RGB
                System.Runtime.InteropServices.Marshal.Copy(redValues, 0, redBmData.Scan0, red_bytes);
                System.Runtime.InteropServices.Marshal.Copy(greenValues, 0, greenBmData.Scan0, green_bytes);
                System.Runtime.InteropServices.Marshal.Copy(blueValues, 0, blueBmData.Scan0, blue_bytes);

                #endregion

                tmpImage.GenImage3("byte", tmpBmp.Width, tmpBmp.Height, redBmData.Scan0, greenBmData.Scan0, blueBmData.Scan0);

                if (GrabImageDone != null)
                {
                    GrabImageDone("GrabSuccess", tmpImage);
                }

                tmpBmp.UnlockBits(tmpBitmapData);
                redBitmap.UnlockBits(redBmData);
                greenBitmap.UnlockBits(greenBmData);
                blueBitmap.UnlockBits(blueBmData);
                rawImage.Dispose();
                convertedImage.Dispose();
                tmpBmp.Dispose();
                redBitmap.Dispose();
                greenBitmap.Dispose();
                blueBitmap.Dispose();
            }
            catch (Exception ex)
            {
                if (GrabImageDone != null)
                {
                    GrabImageDone("GrabFail", tmpImage);
                }
            }
        }

        /// <summary>
        /// 将图片显示到图相框中
        /// </summary>
        public void UpdateImage(HWindowControl viewPort)
        {
            HWndCtrl viewController = new HWndCtrl(viewPort);
            ROIController roiController = new ROIController();
            viewController.resetAll();
            viewController.useROIController(roiController);
            viewController.setViewState(HWndCtrl.MODE_VIEW_NONE);

            viewController.addIconicVar(image);
            viewController.repaint();
            //image.Dispose();
        }

        /// <summary>
        /// 保存图片
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="fileName"></param>
        public void SaveImage(string filePath, string fileName)
        {
            image.WriteImage("tiff", 0, filePath + "\\" + fileName);
        }
        
        public void SetExposure(float exposure)
        {
            CameraProperty cp = cam.GetProperty(PropertyType.Shutter);
            cp.absValue = exposure;
            cp.autoManualMode = false;
            cam.SetProperty(cp);
        }

        private static System.Threading.Mutex _mutex;

        private System.Threading.Mutex GetMutexLock()
        {
            System.Threading.Interlocked.CompareExchange(ref _mutex, new System.Threading.Mutex(), null);
            return _mutex;
        }
    }
}