SlnMesnac.SmartHotspot/SlnMesnac.WPF/Page/IndexControl.xaml.cs

using Microsoft.Extensions.DependencyInjection;
using SlnMesnac.Business;
using SlnMesnac.Config;
using SlnMesnac.Model.dto;
using SlnMesnac.Serilog;
using SlnMesnac.WPF.ViewModel;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Channels;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using static SlnMesnac.WPF.CHCNetSDK;

namespace SlnMesnac.WPF.Page
{
    /// <summary>
    /// IndexControl.xaml 的交互逻辑
    /// </summary>
    public partial class IndexControl : UserControl
    {
        private IndexControlViewModel indexControlViewModel = new IndexControlViewModel();
        private SerilogHelper serilogHelper = null;
        private AppConfig _appConfig = null;
        private AutoModeBusiness taskBusiness = null;
        private InspModeBusiness inspModeBusiness = null;

        private bool m_bInitSDK = false;
        private Int32 m_lUserID = -1;
        private Int32 m_lRealHandle_1 = -1;
        private Int32 m_lRealHandle_2 = -1;
        public CHCNetSDK.NET_DVR_DEVICEINFO_V30 DeviceInfo;
        public CHCNetSDK.NET_DVR_IPPARACFG_V40 m_struIpParaCfgV40;
        public CHCNetSDK.NET_DVR_PTZPOS m_struPtzCfg;
        private bool bAuto = false;
        private CHCNetSDK.RemoteConfigCallback _callback;
        private CHCNetSDK.MSGCallBack_V31 m_falarmData_V31 = null;

        private string DVRIPAddress = "192.168.1.64";       //设备IP地址或者域名 Device IP
        private Int16 DVRPortNumber = 8000;                //设备服务端口号 Device Port
        private string DVRUserName = "admin";               //设备登录用户名 User name to login
        private string DVRPassword = "haiwei@2024";         //设备登录密码 Password to login

        public IndexControl()
        {
            InitializeComponent();
            this.DataContext = indexControlViewModel;
            serilogHelper = App.ServiceProvider.GetService<SerilogHelper>();
            _appConfig = App.ServiceProvider.GetService<AppConfig>();
            taskBusiness = App.ServiceProvider.GetService<AutoModeBusiness>();
            inspModeBusiness = App.ServiceProvider.GetService<InspModeBusiness>();
            _callback = new CHCNetSDK.RemoteConfigCallback(GetThermInfoCallback);

            
            Open_Device();

            taskBusiness.CaptureAlarmPictureEvent += CapturePicture;
        }


        private void Open_Device()
        {
            try
            {
                Task.Run(() =>
                {
                    m_bInitSDK = CHCNetSDK.NET_DVR_Init();
                    if (m_bInitSDK == false)
                    {
                        DebugInfo("热成像双光谱微型云台初始化失败 error!");
                        return;
                    }
                    else
                    {
                        //保存SDK日志 To save the SDK log
                        CHCNetSDK.NET_DVR_SetLogToFile(3, "C:\\SdkLog\\", true);
                        DebugInfo("热成像双光谱微型云台初始化成功!");

                    }

                    m_lUserID = CHCNetSDK.NET_DVR_Login_V30(DVRIPAddress, DVRPortNumber, DVRUserName, DVRPassword, ref DeviceInfo);

                    if (m_lUserID < 0)
                    {
                        string str = "热成像双光谱微型云台打开失败, error code= " + CHCNetSDK.NET_DVR_GetLastError(); ; //登录失败，输出错误号 Failed to login and output the error code
                        DebugInfo(str);
                    }
                    else
                    {
                        //登录成功
                        DebugInfo("热成像双光谱微型云台打开成功!");

                        //SceneryPreview();
                        //ThermalPreview();

                        ///
                        /// 加载实时温度数据
                        ///
                        var size = Marshal.SizeOf(typeof(CHCNetSDK.NET_DVR_REALTIME_THERMOMETRY_COND));
                        CHCNetSDK.NET_DVR_REALTIME_THERMOMETRY_COND struThermCond = new CHCNetSDK.NET_DVR_REALTIME_THERMOMETRY_COND();
                        struThermCond.dwSize = (uint)size;
                        struThermCond.byRuleID = 0;       //规则ID，0代表获取全部规则，具体规则ID从1开始
                        struThermCond.dwChan = 2;// dwChannel; //从1开始，0xffffffff代表获取全部通道

                        IntPtr pCond = Marshal.AllocCoTaskMem(size);
                        Marshal.StructureToPtr(struThermCond, pCond, false);
                        var ret = NET_DVR_StartRemoteConfig(m_lUserID, NET_DVR_GET_REALTIME_THERMOMETRY, pCond, size, _callback, IntPtr.Zero);
                        if (ret < 0)
                        {
                            DebugInfo("配置测温失败, 错误代码：" + NET_DVR_GetLastError()); //登录失败，输出错误号
                            return;
                        }
                    }
                });
                
            }
            catch (Exception ex)
            {
                DebugInfo($"热成像双光谱微型云台加载异常: {ex.Message}");
            }
        }

        /// <summary>
        /// 测温回调函数
        /// </summary>
        /// <param name="dwType"></param>
        /// <param name="lpBuffer"></param>
        /// <param name="dwBufLen"></param>
        /// <param name="pUserData"></param>
        public void GetThermInfoCallback(uint dwType, IntPtr lpBuffer, uint dwBufLen, IntPtr pUserData)
        {
            var ret = Marshal.PtrToStructure<NET_DVR_THERMOMETRY_UPLOAD>(lpBuffer);
            taskBusiness._realTemperatureInfo.fMaxTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fMaxTemperature, 1);
            taskBusiness._realTemperatureInfo.fMinTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fMinTemperature);
            taskBusiness._realTemperatureInfo.fAverageTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fAverageTemperature, 1);
            taskBusiness._realTemperatureInfo.fTemperatureDiff = (float)Math.Round(ret.struLinePolygonThermCfg.fTemperatureDiff, 1);

            var real = new RealTemperatureInfo()
            {
                fMaxTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fMaxTemperature, 1),
                fMinTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fMinTemperature, 1),
                fAverageTemperature = (float)Math.Round(ret.struLinePolygonThermCfg.fAverageTemperature, 1),
                fTemperatureDiff = (float)Math.Round(ret.struLinePolygonThermCfg.fTemperatureDiff, 1),
            };

            indexControlViewModel.RefreshRealTemperature(real);
        }

        /// <summary>
        /// 抓拍图像
        /// </summary>
        /// <param name="sJpegPicFileName"></param>
        public void CapturePicture(string sJpegPicFileName)
        {
            for (int i = 1; i < 3; i++)
            {
                CHCNetSDK.NET_DVR_JPEGPARA lpJpegPara = new CHCNetSDK.NET_DVR_JPEGPARA();
                lpJpegPara.wPicQuality = 0;
                lpJpegPara.wPicSize = 0xff;
                var path = string.Empty;
                if (i == 1)
                {
                    path = $"{_appConfig.visibleRangePath}\\{sJpegPicFileName}";
                }
                else
                {
                    path = $"{_appConfig.infraredImagePath}\\{sJpegPicFileName}";
                }

                if (!CHCNetSDK.NET_DVR_CaptureJPEGPicture(m_lUserID, i, ref lpJpegPara, path))
                {
                    var str = "高温报警，图像信息保存失败, error code= " + NET_DVR_GetLastError();
                    DebugInfo(str);
                    return;
                }
                else
                {
                    var str = "高温报警，图像信息保存成功: " + path;
                    DebugInfo(str);
                }
            }
        }

        /// <summary>
        /// 可见光预览
        /// </summary>
        private void SceneryPreview()
        {
            try
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    CHCNetSDK.NET_DVR_PREVIEWINFO lpPreviewInfo = new CHCNetSDK.NET_DVR_PREVIEWINFO();
                    lpPreviewInfo.hPlayWnd = RealPlayWnd.Handle;//预览窗口 live view window
                    lpPreviewInfo.lChannel = 1;//预览的设备通道 the device channel number
                    lpPreviewInfo.dwStreamType = 0;//码流类型：0-主码流，1-子码流，2-码流3，3-码流4，以此类推
                    lpPreviewInfo.dwLinkMode = 0;//连接方式：0- TCP方式，1- UDP方式，2- 多播方式，3- RTP方式，4-RTP/RTSP，5-RSTP/HTTP 
                    lpPreviewInfo.bBlocked = true; //0- 非阻塞取流，1- 阻塞取流
                    lpPreviewInfo.dwDisplayBufNum = 15; //播放库显示缓冲区最大帧数

                    IntPtr pUser = IntPtr.Zero;//用户数据 user data 

                    m_lRealHandle_1 = CHCNetSDK.NET_DVR_RealPlay_V40(m_lUserID, ref lpPreviewInfo, null/*RealData*/, pUser);

                    if (m_lRealHandle_1 < 0)
                    {
                        var str = "光景图像预览加载失败, error code= " + CHCNetSDK.NET_DVR_GetLastError(); //预览失败，输出错误号 failed to start live view, and output the error code.
                        DebugInfo(str);
                    }
                    else
                    {
                        //预览成功
                        DebugInfo("光景图像预览加载成功!");
                    }
                });
                
            }
            catch (Exception ex)
            {

                serilogHelper.Camera($"光景图像预览加载异常:{ex.Message}");
            }
        }

        /// <summary>
        /// 热成像预览
        /// </summary>
        private void ThermalPreview()
        {
            try
            {
                App.Current.Dispatcher.Invoke(() =>
                {
                    CHCNetSDK.NET_DVR_PREVIEWINFO lpPreviewInfo = new CHCNetSDK.NET_DVR_PREVIEWINFO();
                    lpPreviewInfo.hPlayWnd = RealPlayWnd2.Handle;//预览窗口 live view window
                    lpPreviewInfo.lChannel = 2;//预览的设备通道 the device channel number
                    lpPreviewInfo.dwStreamType = 0;//码流类型：0-主码流，1-子码流，2-码流3，3-码流4，以此类推
                    lpPreviewInfo.dwLinkMode = 0;//连接方式：0- TCP方式，1- UDP方式，2- 多播方式，3- RTP方式，4-RTP/RTSP，5-RSTP/HTTP 
                    lpPreviewInfo.bBlocked = true; //0- 非阻塞取流，1- 阻塞取流
                    lpPreviewInfo.dwDisplayBufNum = 15; //播放库显示缓冲区最大帧数

                    IntPtr pUser = IntPtr.Zero;//用户数据 user data 

                    m_lRealHandle_2 = CHCNetSDK.NET_DVR_RealPlay_V40(m_lUserID, ref lpPreviewInfo, null/*RealData*/, pUser);

                    if (m_lRealHandle_2 < 0)
                    {
                        var str = "热成像预览加载失败, error code= " + CHCNetSDK.NET_DVR_GetLastError(); //预览失败，输出错误号 failed to start live view, and output the error code.
                        DebugInfo(str);
                    }
                    else
                    {
                        //预览成功
                        DebugInfo("热成像预览加载成功!");
                    }
                });
                
            }
            catch (Exception ex)
            {

                serilogHelper.Camera($"热成像图像预览加载异常:{ex.Message}");
            }
        }

        /// <summary>
        /// 关闭设备
        /// </summary>
        private void Close_Device()
        {
            if (!CHCNetSDK.NET_DVR_Logout(m_lUserID))
            {
                var str = "NET_DVR_Logout failed, error code= " + CHCNetSDK.NET_DVR_GetLastError(); ;
                DebugInfo(str);
                return;
            }
            DebugInfo("NET_DVR_Logout succ!");
        }

        /// <summary>
        /// 日志记录
        /// </summary>
        /// <param name="str"></param>
        private void DebugInfo(string str)
        {
            serilogHelper.Camera(str);
        }

        #region 云台控制
        private void btnUp_MouseDown(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.TILT_UP, 0, 4);
        }

        private void btnUp_MouseUp(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.TILT_UP, 1, 4);
        }

        private void btnDown_MouseDown(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.TILT_DOWN, 0, 4);
        }

        private void btnDown_MouseUp(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.TILT_DOWN, 1, 4);
        }

        private void btnLeft_MouseDown(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, (uint)CHCNetSDK.PAN_LEFT, 0, 4);
        }

        private void btnLeft_MouseUp(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_LEFT, 1, 4);
        }

        private void btnRight_MouseDown(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_RIGHT, 0, 4);
        }

        private void btnRight_MouseUp(object sender, MouseButtonEventArgs e)
        {
            CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_RIGHT, 1, 4);
        } 
        #endregion

        /// <summary>
        /// 云台回零点
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_ptz_set_Click(object sender, RoutedEventArgs e)
        {

            if (bAuto)
            {
                CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_AUTO, 1, 4);
                btnAuto.Text = "Auto";
                bAuto = false;
            }

            float wPanPos, wTiltPos, wZoomPos;
            var flag = 0;
            m_struPtzCfg.wAction = 1;

            m_struPtzCfg.wPanPos = (ushort)(Convert.ToUInt16("20", 16));
            m_struPtzCfg.wTiltPos = (ushort)(Convert.ToUInt16("4", 16));
            m_struPtzCfg.wZoomPos = (ushort)(Convert.ToUInt16("10", 16));

            while (flag == 0)
            {

                Int32 nSize = Marshal.SizeOf(m_struPtzCfg);
                IntPtr ptrPtzCfg = Marshal.AllocHGlobal(nSize);
                Marshal.StructureToPtr(m_struPtzCfg, ptrPtzCfg, false);

                if (!CHCNetSDK.NET_DVR_SetDVRConfig(m_lUserID, CHCNetSDK.NET_DVR_SET_PTZPOS, 1, ptrPtzCfg, (UInt32)nSize))
                {
                    var str = "云台回零加载异常, error code= " + CHCNetSDK.NET_DVR_GetLastError();
                    //设置POS参数失败
                    DebugInfo(str);
                    return;
                }
                else
                {
                    DebugInfo("云台回零加载成功!");
                    break;
                }

                Marshal.FreeHGlobal(ptrPtzCfg);

            }
        }

        private void btn_auto_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (!bAuto)
            {
                CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_AUTO, 0, 4);
                btnAuto.Text = "Stop";
                bAuto = true;
            }
            else
            {
                CHCNetSDK.NET_DVR_PTZControlWithSpeed(m_lRealHandle_1, CHCNetSDK.PAN_AUTO, 1, 4);
                btnAuto.Text = "Auto";
                bAuto = false;
            }
        }

        private bool is_insp_model = false;
        /// <summary>
        /// 巡检模式
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_inspmode_MouseDown(object sender, MouseButtonEventArgs e)
        {
            

            if (!is_insp_model)
            {

                if (is_auto_model)
                {
                    MessageBox.Show("当前处于自动模式中，请先关闭自动模式，再开启巡检模式");
                    return;
                }

                btn_automatic.Background = new SolidColorBrush(Colors.LightBlue);
                is_insp_model = true;
                string taskCode = DateTime.Now.ToString("yyyyMMddHHmmssffff");
                string fileName = $"{taskCode}.mp4";
                Task.Run(() =>
                {
                    var url = $"{_appConfig.videoFilePath}\\可见光\\{fileName}";
                    CHCNetSDK.NET_DVR_MakeKeyFrame(m_lUserID, 1);
                    if (!CHCNetSDK.NET_DVR_SaveRealData(m_lRealHandle_1, url))
                    {
                        var str = "可见光通道开启巡检录像失败, error code= " + NET_DVR_GetLastError();
                        DebugInfo(str);
                        return;
                    }
                    else
                    {
                        DebugInfo($"可见光通道开启巡检录像成功");
                    }
                });

                Task.Run(() =>
                {
                    var url = $"{_appConfig.videoFilePath}\\热成像\\{fileName}";
                    CHCNetSDK.NET_DVR_MakeKeyFrame(m_lUserID, 2);
                    if (!CHCNetSDK.NET_DVR_SaveRealData(m_lRealHandle_2, url))
                    {
                        var str = "热成像通道开启巡检录像失败, error code= " + NET_DVR_GetLastError();
                        DebugInfo(str);
                        return;
                    }
                    else
                    {
                        DebugInfo($"热成像通道开启巡检录像成功");
                    }
                });

                inspModeBusiness.Start(taskCode, fileName);
            }
            else
            {
                //MessageBox.Show("巡检模式关闭");
                btn_automatic.Background = new SolidColorBrush(Colors.Transparent);
                is_insp_model = false;


                Task.Run(() =>
                {
                    if (!CHCNetSDK.NET_DVR_StopSaveRealData(m_lRealHandle_1))
                    {
                        var str = "可见光通道关闭巡检录像失败, error code= " + NET_DVR_GetLastError();
                        DebugInfo(str);
                        return;
                    }
                    else
                    {
                        DebugInfo($"可见光通道关闭巡检录像成功");
                    }
                });

                Task.Run(() =>
                {
                    if (!CHCNetSDK.NET_DVR_StopSaveRealData(m_lRealHandle_2))
                    {
                        var str = "热成像通道关闭巡检录像失败, error code= " + NET_DVR_GetLastError();
                        DebugInfo(str);
                        return;
                    }
                    else
                    {
                        DebugInfo($"热成像通道关闭巡检录像成功");
                    }
                });
            }
        }

        private bool is_auto_model = false;
        private void btn_automode_MouseDown(object sender, MouseButtonEventArgs e)
        {
            if (!is_auto_model)
            {
                if (is_insp_model)
                {
                    MessageBox.Show("当前处于巡检模式中，请先关闭巡检模式，再开启自动模式");
                }
                btn_autotask.Background = new SolidColorBrush(Colors.LightBlue);
                is_auto_model = true;
                taskBusiness.Start();
            }
            else
            {
                btn_autotask.Background = new SolidColorBrush(Colors.Transparent);
                is_auto_model = false;
                taskBusiness.Stop();

            }
        }

        /// <summary>
        /// 开启预览
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_start_preview_Click(object sender, RoutedEventArgs e)
        {
            if (m_lRealHandle_1 > 0 || m_lRealHandle_2 > 0)
            {
                MessageBox.Show("实时预览已开启，请勿重复开启");
                return;
            }
            SceneryPreview();
            ThermalPreview();
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_stop_preview_Click(object sender, RoutedEventArgs e)
        {
            if (!CHCNetSDK.NET_DVR_StopRealPlay(m_lRealHandle_1))
            {
                var str = "NET_DVR_StopRealPlay failed, error code= " + CHCNetSDK.NET_DVR_GetLastError(); ;
                DebugInfo(str);
                return;
            }
            else
            {
                DebugInfo("NET_DVR_StopRealPlay succ!");
                RealPlayWnd.Invalidate();//刷新窗口 refresh the window
            }

            if (!CHCNetSDK.NET_DVR_StopRealPlay(m_lRealHandle_2))
            {
                var str = "NET_DVR_StopRealPlay failed, error code= " + CHCNetSDK.NET_DVR_GetLastError(); ;
                DebugInfo(str);
                return;
            }
            else
            {
                DebugInfo("NET_DVR_StopRealPlay succ!");
                RealPlayWnd2.Invalidate();//刷新窗口 refresh the window
                m_lRealHandle_2 = 0;
            }
        }
    }
}