TeamAAS-2.5/TeamAAS.Core/TeamAAS.Camera/Cameras/GalaxyCamera.cs

using GxIAPINET;
using System.ComponentModel;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;
using TeamAAS.Camera.Images;
using TeamAAS.Camera.Models;
using TeamAAS.Camera.Attributes;
using TeamAAS.Camera.Enums;
namespace TeamAAS.Camera.Cameras
{
    /// <summary>
    /// 大恒相机（GxIAPINET SDK）
    /// </summary>
    [Camera("Galaxy", "大恒相机")]
    public class GalaxyCamera : CameraBase
    {
        #region 字段
        static IGXFactory m_objIGXFactory = null;
        IGXDevice m_objIGXDevice = null;
        IGXStream m_objIGXStream = null;
        static List<IGXDeviceInfo> m_listIGXDeviceInfo = new List<IGXDeviceInfo>();
        IGXFeatureControl m_objIGXFeatureControl = null;
        IGXFeatureControl m_objIGXStreamFeatureControl = null;
        IntPtr m_pOutBuffer = IntPtr.Zero;
        IntPtr m_pBitmapInfo = IntPtr.Zero;
        bool m_bIsColor = false;
        byte[] m_byMonoBuffer = null;
        byte[] m_byColorBuffer = null;
        int m_nWidth = 0;
        int m_nHeight = 0;
        IGXImageFormatConvert m_objImageFormatConvert = null;
        CWin32Bitmaps.BITMAPINFO m_objBitmapInfo = new CWin32Bitmaps.BITMAPINFO();
        private bool IsHaveCamera = false;
        #endregion

        [Browsable(false)]
        public override string CameraBrand => "大恒相机";

        public GalaxyCamera(Guid id, int index, string name, string serialNumber, string cameraIp, bool isFindByIp)
            : base(id, index, name, serialNumber, cameraIp, isFindByIp)
        {
            var list = GetDevices();
            foreach (var device in list)
            {
                if (device.CameraType == CameraType.GIGE)
                {
                    if (IsFindByIp)
                    {
                        if (device.CameraIp == CameraIp)
                        {
                            IsHaveCamera = true;
                            ManufacturerName = device.ManufacturerName;
                            ModelName = device.Model;
                            SerialNumber = device.SerialNumber;
                            CameraType = CameraType.GIGE;
                            break;
                        }
                    }
                    else
                    {
                        if (device.SerialNumber == serialNumber)
                        {
                            IsHaveCamera = true;
                            ManufacturerName = device.ManufacturerName;
                            ModelName = device.Model;
                            SerialNumber = device.SerialNumber;
                            CameraType = CameraType.GIGE;
                            break;
                        }
                    }
                }
                else
                {
                    if (device.SerialNumber == serialNumber)
                    {
                        IsHaveCamera = true;
                        ManufacturerName = device.ManufacturerName;
                        ModelName = device.Model;
                        SerialNumber = device.SerialNumber;
                        CameraType = CameraType.GIGE;
                        break;
                    }
                }
            }
            IsConnected = false;
        }

        #region 设备发现

        public static CameraInfo[] GetDevices()
        {
            m_objIGXFactory = IGXFactory.GetInstance();
            m_objIGXFactory.Init();
            List<CameraInfo> cameras = new List<CameraInfo>();
            if (!CheckSoftwareInstalled().isInstalled)
            {
                return cameras.ToArray();
            }
            m_listIGXDeviceInfo.Clear();
            if (null != m_objIGXFactory)
            {
                m_objIGXFactory.UpdateAllDeviceList(200, m_listIGXDeviceInfo);
            }
            if (m_listIGXDeviceInfo.Count <= 0)
            {
                return cameras.ToArray();
            }
            for (int i = 0; i < m_listIGXDeviceInfo.Count; i++)
            {
                var deviceType = m_listIGXDeviceInfo[i].GetDeviceClass();
                if (deviceType == GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_GEV)
                {
                    cameras.Add(new CameraInfo()
                    {
                        CameraNo = i + 1,
                        CameraName = m_listIGXDeviceInfo[i].GetDisplayName(),
                        CameraBrand = "大恒相机",
                        CameraType = CameraType.GIGE,
                        ManufacturerName = m_listIGXDeviceInfo[i].GetVendorName(),
                        Model = m_listIGXDeviceInfo[i].GetModelName(),
                        SerialNumber = m_listIGXDeviceInfo[i].GetSN(),
                        CameraIp = m_listIGXDeviceInfo[i].GetIP(),
                        IsFindByIp = true,
                    });
                }
                else if (deviceType == GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_USB2 || deviceType == GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_U3V)
                {
                    cameras.Add(new CameraInfo()
                    {
                        CameraNo = i + 1,
                        CameraName = m_listIGXDeviceInfo[i].GetDisplayName(),
                        CameraBrand = "大恒相机",
                        CameraType = CameraType.USB,
                        ManufacturerName = m_listIGXDeviceInfo[i].GetVendorName(),
                        Model = m_listIGXDeviceInfo[i].GetModelName(),
                        SerialNumber = m_listIGXDeviceInfo[i].GetSN(),
                        CameraIp = "",
                    });
                }
                else if (deviceType == GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_UNKNOWN)
                {
                    cameras.Add(new CameraInfo()
                    {
                        CameraNo = i + 1,
                        CameraName = m_listIGXDeviceInfo[i].GetDisplayName(),
                        CameraBrand = "大恒相机",
                        CameraType = CameraType.Unknown,
                        ManufacturerName = m_listIGXDeviceInfo[i].GetVendorName(),
                        Model = m_listIGXDeviceInfo[i].GetModelName(),
                        SerialNumber = m_listIGXDeviceInfo[i].GetSN(),
                        CameraIp = "",
                    });
                }
            }
            return cameras.ToArray();
        }

        public static (bool isInstalled, string version) CheckSoftwareInstalled()
        {
            string softwareName = "Galaxy";
            string softwareVersion = "2.4.2504";
            string[] registryPaths = new[]
            {
                @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
                @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall"
            };
            foreach (var path in registryPaths)
            {
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(path))
                {
                    if (key == null) continue;

                    foreach (string subKeyName in key.GetSubKeyNames())
                    {
                        using (RegistryKey subKey = key.OpenSubKey(subKeyName))
                        {
                            string displayName = subKey?.GetValue("DisplayName")?.ToString();
                            if (displayName != null && displayName.Contains(softwareName))
                            {
                                string version = subKey.GetValue("DisplayName")?.ToString();
                                var match = Regex.Match(version, @"\d+(?:\.\d+)+");
                                if (match.Success)
                                {
                                    version = match.Value;
                                }
                                else
                                {
                                    continue;
                                }
                                Version v1 = new Version(version);
                                Version v2 = new Version(softwareVersion);
                                if (v1 >= v2)
                                {
                                    return (true, version);
                                }
                                else
                                {
                                    return (false, version);
                                }
                            }
                        }
                    }
                }
            }
            return (false, "");
        }

        #endregion

        #region SDK 实现

        public override bool OpenDevice()
        {
            using (WriteLockScope())
            {
                try
                {
                    var list = GetDevices();
                    foreach (var device in list)
                    {
                        if (device.SerialNumber == SerialNumber)
                        {
                            IsHaveCamera = true;
                            break;
                        }
                    }
                    if (!IsHaveCamera)
                    {
                        return false;
                    }

                    if (null != m_objIGXDevice)
                    {
                        m_objIGXDevice.Close();
                        m_objIGXDevice = null;
                    }
                    m_objIGXDevice = m_objIGXFactory.OpenDeviceBySN(SerialNumber, GxIAPINET.GX_ACCESS_MODE.GX_ACCESS_EXCLUSIVE);
                    m_objIGXFeatureControl = m_objIGXDevice.GetRemoteFeatureControl();
                    if (null != m_objIGXDevice)
                    {
                        m_objIGXStream = m_objIGXDevice.OpenStream(0);
                        m_objIGXStreamFeatureControl = m_objIGXStream.GetFeatureControl();
                    }
                    GX_DEVICE_CLASS_LIST objDeviceClass = m_objIGXDevice.GetDeviceInfo().GetDeviceClass();
                    if (GX_DEVICE_CLASS_LIST.GX_DEVICE_CLASS_GEV == objDeviceClass)
                    {
                        if (true == m_objIGXFeatureControl.IsImplemented("GevSCPSPacketSize"))
                        {
                            uint nPacketSize = m_objIGXStream.GetOptimalPacketSize();
                            m_objIGXFeatureControl.GetIntFeature("GevSCPSPacketSize").SetValue(nPacketSize);
                        }
                    }
                    if (null != m_objIGXFeatureControl)
                    {
                        // 按当前触发模式下发（默认连续采集 = TriggerMode Off，与历史硬编码一致）
                        ApplyTriggerToHardware(TriggerMode);
                    }

                    ReleaseBuffer();
                    GxBitmap();

                    if (null != m_objIGXStreamFeatureControl)
                    {
                        try
                        {
                            m_objIGXStreamFeatureControl.GetEnumFeature("StreamBufferHandlingMode").SetValue("OldestFirst");
                        }
                        catch (Exception)
                        {
                        }
                    }

                    if (!IsConnected)
                    {
                        OnConnectChanged(true);
                    }
                    IsConnected = true;
                    return IsConnected;
                }
                catch (Exception ex)
                {
                    ErrorMessage = ex.Message;
                    IsConnected = false;
                    return false;
                }
            }
        }

        public override void CloseDevice()
        {
            using (WriteLockScope())
            {
                try
                {
                    if (null != m_objIGXStream)
                    {
                        m_objIGXStream.StopGrab();
                        m_objIGXStream.UnregisterCaptureCallback();
                        m_objIGXStream.Close();
                        m_objIGXStream = null;
                        m_objIGXStreamFeatureControl = null;
                    }
                    if (null != m_objIGXDevice)
                    {
                        m_objIGXDevice.Close();
                        m_objIGXDevice = null;
                    }
                    if (null != m_objIGXFactory)
                    {
                        m_objIGXFactory.Uninit();
                    }
                }
                catch (Exception)
                {
                }

                ReleaseBuffer();
                IsConnected = false;
                OnConnectChanged(false);
            }
        }

        #region 触发模式

        /// <summary>大恒（Galaxy）支持连续/软触发/硬触发（Line0）</summary>
        public override IReadOnlyList<CameraTriggerMode> SupportedTriggerModes => FullTriggerModes;

        /// <summary>历史行为：OpenDevice 硬编码 TriggerMode=Off，故默认连续采集</summary>
        protected override CameraTriggerMode DefaultTriggerMode => CameraTriggerMode.连续采集;

        protected override bool ApplyTriggerMode(CameraTriggerMode mode)
        {
            using (WriteLockScope())
                return ApplyTriggerToHardware(mode);
        }

        /// <summary>
        /// 把触发模式下发到大恒 GxIAPINET（GenICam 字符串接口）。
        /// 调用方需已持有写锁（OpenDevice/Grab 内部已在锁内；锁可重入）。
        /// </summary>
        private bool ApplyTriggerToHardware(CameraTriggerMode mode)
        {
            if (null == m_objIGXFeatureControl) return false;

            m_objIGXFeatureControl.GetEnumFeature("AcquisitionMode").SetValue("Continuous");

            switch (mode)
            {
                case CameraTriggerMode.连续采集:
                    m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("Off");
                    return true;

                case CameraTriggerMode.软触发:
                    m_objIGXFeatureControl.GetEnumFeature("TriggerSource").SetValue("Software");
                    m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("On");
                    return true;

                case CameraTriggerMode.硬触发上升沿:
                case CameraTriggerMode.硬触发下降沿:
                    m_objIGXFeatureControl.GetEnumFeature("TriggerSource").SetValue("Line0");
                    m_objIGXFeatureControl.GetEnumFeature("TriggerActivation").SetValue(
                        mode == CameraTriggerMode.硬触发上升沿 ? "Rising" : "Falling");
                    m_objIGXFeatureControl.GetEnumFeature("TriggerMode").SetValue("On");
                    return true;

                default: // 跟随相机：不下发，沿用相机自身配置
                    return true;
            }
        }

        #endregion

        public override GenImage Grab()
        {
            using (WriteLockScope())
            {
                var sw = Stopwatch.StartNew();
                dynamic objIImageData = null;
                try
                {
                    if (null == m_objIGXDevice || !IsConnected)
                    {
                        ErrorMessage = "相机未连接";
                        return null;
                    }

                    if (null != m_objIGXStream)
                    {
                        m_objIGXStream.StartGrab();
                    }
                    if (null != m_objIGXFeatureControl)
                    {
                        m_objIGXFeatureControl.GetCommandFeature("AcquisitionStart").Execute();

                        // 仅软触发模式需主动发触发命令；连续采集自由出图，硬触发等外部信号
                        if (IsSoftwareTrigger)
                            m_objIGXFeatureControl.GetCommandFeature("TriggerSoftware").Execute();
                    }
                    objIImageData = m_objIGXStream.GetImageNoThrow(500);

                    GX_VALID_BIT_LIST emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
                    if (null != objIImageData)
                    {
                        emValidBits = GetBestValudBit(objIImageData.GetPixelFormat());
                        if (GX_FRAME_STATUS_LIST.GX_FRAME_STATUS_SUCCESS == objIImageData.GetStatus())
                        {
                            if (m_bIsColor)
                            {
                                IntPtr pRGB24Buffer = IntPtr.Zero;
                                if (objIImageData.GetPixelFormat() == GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BGR8)
                                {
                                    byte[] byColorBufferTmp = new byte[__GetStride(m_nWidth, m_bIsColor) * m_nHeight];
                                    Marshal.Copy(objIImageData.GetBuffer(), byColorBufferTmp, 0, __GetStride(m_nWidth, m_bIsColor) * m_nHeight);
                                    pRGB24Buffer = objIImageData.GetBuffer();
                                    for (int i = 0; i < m_nHeight; i++)
                                    {
                                        Buffer.BlockCopy(byColorBufferTmp, (m_nHeight - i - 1) * m_nWidth * 3, m_byColorBuffer, i * m_nWidth * 3, m_nWidth * 3);
                                    }
                                }
                                else
                                {
                                    m_objImageFormatConvert.SetDstFormat(GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BGR8);
                                    UInt64 i64DstBufferize = m_objImageFormatConvert.GetBufferSizeForConversion(objIImageData);
                                    m_objImageFormatConvert.SetValidBits(emValidBits);
                                    m_objImageFormatConvert.Convert(objIImageData, m_pOutBuffer, i64DstBufferize, true);
                                    Marshal.Copy(m_pOutBuffer, m_byColorBuffer, 0, __GetStride(m_nWidth, m_bIsColor) * m_nHeight);
                                    pRGB24Buffer = m_pOutBuffer;
                                }
                                Image = GenImage.FromIntPtr(m_nWidth, m_nHeight, PixelType.BGR24, pRGB24Buffer, m_nWidth * 3);
                            }
                            else
                            {
                                IntPtr pRaw8Buffer = IntPtr.Zero;
                                if (__IsPixelFormat8(objIImageData.GetPixelFormat()))
                                {
                                    byte[] byMonoBufferTmp = new byte[__GetStride(m_nWidth, m_bIsColor) * m_nHeight];
                                    Marshal.Copy(objIImageData.GetBuffer(), byMonoBufferTmp, 0, __GetStride(m_nWidth, m_bIsColor) * m_nHeight);
                                    pRaw8Buffer = objIImageData.GetBuffer();
                                    for (int i = 0; i < m_nHeight; i++)
                                    {
                                        Buffer.BlockCopy(byMonoBufferTmp, (m_nHeight - i - 1) * m_nWidth, m_byMonoBuffer, i * m_nWidth, m_nWidth);
                                    }
                                }
                                else
                                {
                                    m_objImageFormatConvert.SetDstFormat(GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO8);
                                    UInt64 i64DstBufferize = m_objImageFormatConvert.GetBufferSizeForConversion(objIImageData);
                                    m_objImageFormatConvert.SetValidBits(emValidBits);
                                    m_objImageFormatConvert.Convert(objIImageData, m_pOutBuffer, i64DstBufferize, true);
                                    Marshal.Copy(m_pOutBuffer, m_byMonoBuffer, 0, __GetStride(m_nWidth, m_bIsColor) * m_nHeight);
                                    pRaw8Buffer = m_pOutBuffer;
                                }
                                Image = GenImage.FromIntPtr(m_nWidth, m_nHeight, PixelType.Grey8, pRaw8Buffer, m_nWidth);
                            }
                        }
                    }
                    if (Image != null)
                    {
                        ImageWidth = (uint)Image.Width;
                        ImageHeight = (uint)Image.Height;
                        ApplyGammaToImage(Image);
                        ErrorMessage = "";
                        TotalTime = sw.Elapsed;
                        return Image;
                    }
                }
                catch (Exception ex)
                {
                    CloseDevice();
                    OpenDevice();
                    ErrorMessage = ex.Message;
                }
                finally
                {
                    if (null != objIImageData)
                    {
                        objIImageData.Destroy();
                    }
                }
                return null;
            }
        }

        public override bool SetExposureTime(float exposureTime)
        {
            using (WriteLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null)
                    {
                        m_objIGXFeatureControl.GetFloatFeature("ExposureTime").SetValue(exposureTime);
                        return true;
                    }
                }
                catch { }
                return true;
            }
        }

        public override float GetExposureTime()
        {
            using (ReadLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null)
                    {
                        return (float)m_objIGXFeatureControl.GetFloatFeature("ExposureTime").GetValue();
                    }
                }
                catch { }
                return 0;
            }
        }

        public override bool SetGain(float gain)
        {
            using (WriteLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null)
                    {
                        m_objIGXFeatureControl.GetFloatFeature("Gain").SetValue(gain);
                        return true;
                    }
                }
                catch { }
                return true;
            }
        }

        public override float GetGain()
        {
            using (ReadLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null)
                    {
                        return (float)m_objIGXFeatureControl.GetFloatFeature("Gain").GetValue();
                    }
                }
                catch { }
                return 0;
            }
        }

        public override bool SetGamma(float gamma)
        {
            using (WriteLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null && m_objIGXFeatureControl.IsImplemented("Gamma"))
                    {
                        m_objIGXFeatureControl.GetFloatFeature("Gamma").SetValue(gamma);
                        return true;
                    }
                }
                catch { }
                UpdateGammaSnapshot(gamma);
                return true;
            }
        }

        public override float GetGamma()
        {
            using (ReadLockScope())
            {
                try
                {
                    if (m_objIGXFeatureControl != null && m_objIGXFeatureControl.IsImplemented("Gamma"))
                    {
                        return (float)m_objIGXFeatureControl.GetFloatFeature("Gamma").GetValue();
                    }
                }
                catch { }
                return Gamma;
            }
        }

        #endregion

        #region 辅助方法

        public void GxBitmap()
        {
            m_objImageFormatConvert = m_objIGXFactory.CreateImageFormatConvert();
            if (null != m_objIGXDevice)
            {
                m_nWidth = (int)m_objIGXDevice.GetRemoteFeatureControl().GetIntFeature("Width").GetValue();
                m_nHeight = (int)m_objIGXDevice.GetRemoteFeatureControl().GetIntFeature("Height").GetValue();

                ImageWidth = (uint)m_nWidth;
                ImageHeight = (uint)m_nHeight;
                IsSupportColor(ref m_bIsColor);
            }

            m_byMonoBuffer = new byte[__GetStride(m_nWidth, m_bIsColor) * m_nHeight];
            m_byColorBuffer = new byte[__GetStride(m_nWidth, m_bIsColor) * m_nHeight];
            m_pOutBuffer = Marshal.AllocCoTaskMem(__GetStride(m_nWidth, m_bIsColor) * m_nHeight);

            if (m_bIsColor)
            {
                m_objBitmapInfo.bmiHeader.biSize = (uint)Marshal.SizeOf(typeof(CWin32Bitmaps.BITMAPINFOHEADER));
                m_objBitmapInfo.bmiHeader.biWidth = m_nWidth;
                m_objBitmapInfo.bmiHeader.biHeight = m_nHeight;
                m_objBitmapInfo.bmiHeader.biPlanes = 1;
                m_objBitmapInfo.bmiHeader.biBitCount = 24;
                m_objBitmapInfo.bmiHeader.biCompression = 0;
                m_objBitmapInfo.bmiHeader.biSizeImage = 0;
                m_objBitmapInfo.bmiHeader.biXPelsPerMeter = 0;
                m_objBitmapInfo.bmiHeader.biYPelsPerMeter = 0;
                m_objBitmapInfo.bmiHeader.biClrUsed = 0;
                m_objBitmapInfo.bmiHeader.biClrImportant = 0;
            }
            else
            {
                m_objBitmapInfo.bmiHeader.biSize = (uint)Marshal.SizeOf(typeof(CWin32Bitmaps.BITMAPINFOHEADER));
                m_objBitmapInfo.bmiHeader.biWidth = m_nWidth;
                m_objBitmapInfo.bmiHeader.biHeight = m_nHeight;
                m_objBitmapInfo.bmiHeader.biPlanes = 1;
                m_objBitmapInfo.bmiHeader.biBitCount = 8;
                m_objBitmapInfo.bmiHeader.biCompression = 0;
                m_objBitmapInfo.bmiHeader.biSizeImage = 0;
                m_objBitmapInfo.bmiHeader.biXPelsPerMeter = 0;
                m_objBitmapInfo.bmiHeader.biYPelsPerMeter = 0;
                m_objBitmapInfo.bmiHeader.biClrUsed = 0;
                m_objBitmapInfo.bmiHeader.biClrImportant = 0;

                m_objBitmapInfo.bmiColors = new CWin32Bitmaps.RGBQUAD[256];
                for (int i = 0; i < 256; i++)
                {
                    m_objBitmapInfo.bmiColors[i].rgbBlue = (byte)i;
                    m_objBitmapInfo.bmiColors[i].rgbGreen = (byte)i;
                    m_objBitmapInfo.bmiColors[i].rgbRed = (byte)i;
                    m_objBitmapInfo.bmiColors[i].rgbReserved = 0;
                }
            }
            m_pBitmapInfo = Marshal.AllocHGlobal(2048);
            Marshal.StructureToPtr(m_objBitmapInfo, m_pBitmapInfo, false);
        }

        public void ReleaseBuffer()
        {
            if (m_pOutBuffer != IntPtr.Zero)
            {
                Marshal.FreeCoTaskMem(m_pOutBuffer);
                m_pOutBuffer = IntPtr.Zero;
            }

            if (m_pBitmapInfo != IntPtr.Zero)
            {
                Marshal.FreeHGlobal(m_pBitmapInfo);
                m_pBitmapInfo = IntPtr.Zero;
            }
        }

        public void IsSupportColor(ref bool bIsColorFilter)
        {
            bool bIsImplemented = false;
            bool bIsMono = false;
            string strPixelFormat = "";
            uint nPixelFormatValue = 0;

            strPixelFormat = m_objIGXDevice.GetRemoteFeatureControl().GetEnumFeature("PixelFormat").GetValue();
            if (0 == string.Compare(strPixelFormat, 0, "Mono", 0, 4))
            {
                bIsMono = true;
            }
            else
            {
                bIsMono = false;
            }

            CDecide.GetConvertPixelFormat(strPixelFormat, ref nPixelFormatValue);
            bIsImplemented = CDecide.GetIsGray(nPixelFormatValue);
            if ((!bIsMono) && (!bIsImplemented))
            {
                bIsColorFilter = true;
            }
            else
            {
                bIsColorFilter = false;
            }
        }

        private int __GetStride(int nWidth, bool bIsColor)
        {
            return bIsColor ? nWidth * 3 : nWidth;
        }

        public GX_VALID_BIT_LIST GetBestValudBit(GX_PIXEL_FORMAT_ENTRY emPixelFormatEntry)
        {
            GX_VALID_BIT_LIST emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
            switch (emPixelFormatEntry)
            {
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_RGB8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BGR8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_R8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_G8:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_B8:
                    emValidBits = GX_VALID_BIT_LIST.GX_BIT_0_7;
                    break;
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10_PACKED:
                    emValidBits = GX_VALID_BIT_LIST.GX_BIT_2_9;
                    break;
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12_PACKED:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12_PACKED:
                    emValidBits = GX_VALID_BIT_LIST.GX_BIT_4_11;
                    break;
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO14:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR14:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG14:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB14:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG14:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG14_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB14_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR14_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG14_P:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO14_P:
                    emValidBits = GX_VALID_BIT_LIST.GX_BIT_6_13;
                    break;
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB16:
                case GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG16:
                    emValidBits = GX_VALID_BIT_LIST.GX_BIT_8_15;
                    break;
                default:
                    break;
            }
            return emValidBits;
        }

        private bool __IsPixelFormat8(GX_PIXEL_FORMAT_ENTRY emPixelFormatEntry)
        {
            const uint PIXEL_FORMATE_BIT = 0x00FF0000;
            const uint GX_PIXEL_8BIT = 0x00080000;
            bool bIsPixelFormat8 = false;
            uint uiPixelFormatEntry = (uint)emPixelFormatEntry;
            if ((uiPixelFormatEntry & PIXEL_FORMATE_BIT) == GX_PIXEL_8BIT)
            {
                bIsPixelFormat8 = true;
            }
            return bIsPixelFormat8;
        }

        public GenImage ConvertImage(UInt32 nWidth, UInt32 nHeight, IntPtr pImageBuf, GX_PIXEL_FORMAT_ENTRY enPixelType)
        {
            try
            {
                if (enPixelType == GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO8)
                {
                    return GenImage.FromIntPtr((int)nWidth, (int)nHeight, PixelType.Grey8, pImageBuf, (int)nWidth);
                }
                else
                {
                    return GenImage.FromIntPtr((int)nWidth, (int)nHeight, PixelType.BGR24, pImageBuf, (int)nWidth * 3);
                }
            }
            catch (System.Exception)
            {
                return null;
            }
        }

        #endregion
    }

    #region Galaxy SDK 辅助类

    internal class CWin32Bitmaps
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPFILEHEADER
        {
            public ushort bfType;
            public int bfSize;
            public ushort bfReserved1;
            public ushort bfReserved2;
            public uint bfOffBits;
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFOHEADER
        {
            public uint biSize;
            public int biWidth;
            public int biHeight;
            public ushort biPlanes;
            public ushort biBitCount;
            public uint biCompression;
            public int biSizeImage;
            public int biXPelsPerMeter;
            public int biYPelsPerMeter;
            public uint biClrUsed;
            public uint biClrImportant;
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct RGBQUAD
        {
            public byte rgbBlue;
            public byte rgbGreen;
            public byte rgbRed;
            public byte rgbReserved;
        }
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFO
        {
            public BITMAPINFOHEADER bmiHeader;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
            public RGBQUAD[] bmiColors;
        }
    }

    internal static class CDecide
    {
        public const uint GVSP_PIX_MONO = 0x01000000;
        public const uint GVSP_PIX_RGB = 0x02000000;
        public const uint GVSP_PIX_CUSTOM = 0x80000000;
        public const uint GVSP_PIX_COLOR_MASK = 0xFF000000;
        public const uint GVSP_PIX_ID_MASK = 0x0000FFFF;

        public static bool GetISMono(uint nPixelFormat)
        {
            return ((GVSP_PIX_COLOR_MASK & nPixelFormat) == GVSP_PIX_MONO);
        }

        public static bool GetIsBayer(uint nPixelFormat)
        {
            bool bIsBayer = (((GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR8) <= (GVSP_PIX_ID_MASK & nPixelFormat)
                               && (GVSP_PIX_ID_MASK & nPixelFormat) <= (GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12))
                               || ((GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR14) <= (GVSP_PIX_ID_MASK & nPixelFormat)
                               && (GVSP_PIX_ID_MASK & nPixelFormat) <= (GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG14))
                               || ((GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR16) <= (GVSP_PIX_ID_MASK & nPixelFormat)
                               && (GVSP_PIX_ID_MASK & nPixelFormat) <= (GVSP_PIX_ID_MASK & (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG16)));
            return bIsBayer;
        }

        public static bool GetIsRGB(uint nPixelFormat)
        {
            return ((GVSP_PIX_COLOR_MASK & nPixelFormat) == GVSP_PIX_RGB);
        }

        public static bool GetIsRGB8(uint nPixelFormat)
        {
            return ((nPixelFormat == (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_RGB8)
                           || (nPixelFormat == (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BGR8));
        }

        public static bool GetIsGray(uint nPixelFormat)
        {
            return (GetISMono(nPixelFormat)) && (!GetIsBayer(nPixelFormat)) && (!GetIsRGB(nPixelFormat));
        }

        public static void GetConvertPixelFormat(String strPixelFormat, ref uint nPixelFormatValue)
        {
            switch (strPixelFormat)
            {
                case "Mono8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO8; break;
                case "BayerRG8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG8; break;
                case "BayerGB8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB8; break;
                case "BayerGR8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR8; break;
                case "BayerBG8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG8; break;
                case "RGB8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_RGB8; break;
                case "BGR8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BGR8; break;
                case "Mono10": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10; break;
                case "Mono10_Packed": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10_PACKED; break;
                case "Mono10_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO10_P; break;
                case "BayerRG10": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10; break;
                case "BayerRG10_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10_P; break;
                case "BayerRG10_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG10_PACKED; break;
                case "BayerGB10": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10; break;
                case "BayerGB10_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10_P; break;
                case "BayerGB10_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB10_PACKED; break;
                case "BayerGR10": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10; break;
                case "BayerGR10_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10_P; break;
                case "BayerGR10_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR10_PACKED; break;
                case "BayerBG10": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10; break;
                case "BayerBG10_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10_P; break;
                case "BayerBG10_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG10_PACKED; break;
                case "Mono12": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12; break;
                case "Mono12_Packed": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12_PACKED; break;
                case "Mono12_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO12_P; break;
                case "BayerRG12": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12; break;
                case "BayerRG12_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12_P; break;
                case "BayerRG12_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG12_PACKED; break;
                case "BayerGB12": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12; break;
                case "BayerGB12_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12_P; break;
                case "BayerGB12_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB12_PACKED; break;
                case "BayerGR12": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12; break;
                case "BayerGR12_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12_P; break;
                case "BayerGR12_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR12_PACKED; break;
                case "BayerBG12": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12; break;
                case "BayerBG12_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12_P; break;
                case "BayerBG12_Packet": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG12_PACKED; break;
                case "Mono14": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO14; break;
                case "Mono14_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO14_P; break;
                case "BayerGR14": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR14; break;
                case "BayerRG14": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG14; break;
                case "BayerGB14": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB14; break;
                case "BayerBG14": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG14; break;
                case "BayerGR14_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR14_P; break;
                case "BayerRG14_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG14_P; break;
                case "BayerGB14_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB14_P; break;
                case "BayerBG14_P": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG14_P; break;
                case "Mono16": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_MONO16; break;
                case "BayerGR16": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GR16; break;
                case "BayerRG16": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_RG16; break;
                case "BayerGB16": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_GB16; break;
                case "BayerBG16": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_BAYER_BG16; break;
                case "R8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_R8; break;
                case "G8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_G8; break;
                case "B8": nPixelFormatValue = (uint)GX_PIXEL_FORMAT_ENTRY.GX_PIXEL_FORMAT_B8; break;
                default: break;
            }
        }
    }

    #endregion
}