smart-bow-infrared/Assets/BowArrow/InfraredCamera/InfraredDemo.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using InfraredManager;
using ZIM;
using System.Linq;
using SLAMUVC;
using System;
using SmartBowSDK;
using ZIM.Unity;

public class InfraredDemo : MonoBehaviour
{
    public static bool DebugInEditor = true;
    public static InfraredDemo _ins;



    [SerializeField]
    RectTransform canvasRectTransform;

    public Button mBtnSee;
    public static void Create()
    {
        if (_ins) return;
        GameObject o = Instantiate(Resources.Load<GameObject>("InfraredDemo"));
        DontDestroyOnLoad(o);
        _ins = o.GetComponent<InfraredDemo>();

        //直接初始化一次
        _ins.InitInfraredCamera();
    }


    void Start()
    {
        if (Application.platform != RuntimePlatform.WindowsEditor) DebugInEditor = false;
        SetVisiable(false);
        InitDebugScreenPoint();
        gameObject.AddComponent<FPSTester>();

        mBtnSee.interactable = false;
        mBtnSee.transform.Find("Text").GetComponent<Text>().text = "等待初始化..";
        //直接初始化一次
        //InitInfraredCamera();

        Debug.Log("[InfraredDemo] Start Function!");

#if UNITY_STANDALONE_WIN 
        _calibrationFixedText.transform.parent.gameObject.SetActive(false);
#endif
    }


    void Update()
    {
        UpdateInfraredCamera();
       //UpdateDebugScreenPoint();
    }

    public void OnClick_See()
    {
        SetVisiable(!_visiable);
    }
   
    //初始化一次 initScreenLocateManual
    bool hasCalled = false;

    bool _visiable;
    void SetVisiable(bool value)
    {
        _visiable = value;
        transform.Find("Background").gameObject.SetActive(value);
        transform.Find("InfraredCamera").gameObject.SetActive(value);
        transform.Find("BtnSee").GetComponentInChildren<Text>().text = value ? "隐藏界面" : "调试红外";
        //if (value) InitInfraredCamera();

        if (!hasCalled && value)
        {
            hasCalled = true;
            //如果本地有记录，初始化一次
            StartCoroutine(initScreenLocateManual());
            Debug.Log("[InfraredDemo] SetVisiable Function!");
        }
    }

    Text _spText;
    Vector2 _screenPoint;
    void InitDebugScreenPoint()
    {
        _spText = transform.Find("SPText").GetComponent<Text>();
        //_spText.gameObject.SetActive(DebugInEditor);
        _spText.gameObject.SetActive(false);
    }
    void UpdateDebugScreenPoint()
    {
        if (!DebugInEditor) return;
        if (infraredCameraHelper == null) return;
        _screenPoint.x = Mathf.Clamp(
            _screenPoint.x + Input.GetAxis("Horizontal") * Screen.width / 400f,
            0, Screen.width);
        _screenPoint.y = Mathf.Clamp(
            _screenPoint.y + Input.GetAxis("Vertical") * Screen.height / 400f,
            0, Screen.height);
        infraredCameraHelper.InvokeOnPositionUpdate(_screenPoint);
        _spText.text = _screenPoint.ToString();
    }

    #region 红外摄像
    [SerializeField] RawImage _cameraRender;
    [SerializeField] RawImage _cameraRender2;

    /// <summary>
    /// 测试texture
    /// </summary>
    public RawImage MyCameraRender2
    {
        get { return _cameraRender2; }
        set { _cameraRender2 = value; }
    }

    //[SerializeField] MaintainAspectRatio _MaintainAspectRatio;
    [SerializeField] List<RectTransform> _crosshairsInCamera;

    [SerializeField] Slider _sliderShakeFilter;

    [SerializeField] Button _btnReset;
    [SerializeField] Button _btnScreenLocateManual;
    [SerializeField] Button _btnScreenLocateManualAuto;

    [SerializeField] Slider _sliderCapture;
    [SerializeField] Slider _sliderDelay;

    [SerializeField] Dropdown _dropdownResolution;
    [SerializeField] Dropdown _dropdownResolution2;

    [SerializeField] Slider _sliderLineWidth;

    //红外线阈值
    [SerializeField] Slider _infraredFilter;

    //调试UVC参数
    [SerializeField] GameObject _cameraParameterPanel;
    [SerializeField] Button _btnAdjusting;


    //野鸭选择
    [SerializeField] Dropdown _duckLevelDropdown;

    //Dictionary<string, ParamFloatValue> dUVCParameters = new Dictionary<string, ParamFloatValue>();

    //public ParamFloatValue brightness = new ParamFloatValue("ic_brightness", 1.0f);
    //public ParamFloatValue saturation = new ParamFloatValue("ic_saturation", 1.0f);
    //public ParamFloatValue contrast = new ParamFloatValue("ic_contrast", 1.0f);

#if UNITY_ANDROID
    //初始化纹理-1280*720,index = 0
    // public ParamFloatValue resoution = new ParamFloatValue("ic_resoution2", 0);
    //摄像机分辨率 -320*240,index = 10
    public ParamFloatValue resoutionNew = new ParamFloatValue("ic_resoutionNew", 10);
    //摄像机分辨率 -只处理高低分辨率情况
    public ParamFloatValue resoution = new ParamFloatValue("ic_resoution", 0);
    string[] resolutions = { "高分辨率", "低分辨率" };
#endif

    //抖动过滤值 - 6.0
    public ParamFloatValue shakeFilterValue = new ParamFloatValue("ic_shakeFilterValue2", 6.0f);
    //亮度过滤阈值  - 0.8
    public ParamFloatValue infraredFileterValue = new ParamFloatValue("ic_infraredFileterValue", 0.8f);


    //线段宽度阈值
    public ParamFloatValue lineWidth = new ParamFloatValue("ic_lineWidth", 10.0f);

    public ParamFloatValue captureValue = new ParamFloatValue("ic_captureValue", 30.0f);
    public ParamFloatValue delayValue = new ParamFloatValue("ic_delayValue", 30.0f);

  
    //红外准心，默认打开吧
    public ParamFloatValue crosshairValue = new ParamFloatValue("ic_crosshairValue",1);

    //野鸭测试存储
    public ParamFloatValue duckHunterLevel = new ParamFloatValue("test_duckHunterLevelValue", 1);

    public static InfraredCameraHelper infraredCameraHelper;
    public static bool running { get => infraredCameraHelper != null; }
    private bool _inited;


    #region 参数控制


    public GameObject togglePrefab; // 拖入一个Toggle预设体
    public GameObject sliderPrefab; // 拖入一个Slider预设体
    public GameObject spawnPoint;
    //自动曝光
    bool bAutoAE = false;
    Toggle CTRLAEToggle;
    Slider CTRLAEABSSlider;
    string[] sliderNameArray = new string[]{
        "自动曝光模式",
        "曝光时间(绝对)",

        "亮度", //
        "对比度",
        "色调",
        "饱和度",
        "锐度",
        "伽玛",
        //"白平衡温度",
        //"白平衡分量",
        "背光补偿",
        "增益" };

    string[] sliderStrArray = new string[]{
        "CTRL_AE",
        "CTRL_AE_ABS",

        "PU_BRIGHTNESS",
        "PU_CONTRAST",
        "PU_HUE",
        "PU_SATURATION",
        "PU_SHARPNESS",
        "PU_GAMMA",
        //"PU_WB_TEMP",
        //"PU_WB_COMPO",
        "PU_BACKLIGHT",
        "PU_GAIN" };

    UVCManager.CameraInfo currentCameraInfo;
    //初始化相机参数
    public void initSlider(UVCManager.CameraInfo cameraInfo)
    {
        if (currentCameraInfo != null) return;
        currentCameraInfo = cameraInfo;

        for (int i = 0; i < sliderStrArray.Length; i++)
        {
            string typeStr = sliderStrArray[i];
           // UInt64 _VALUE = cameraInfo.GetTypeByName(typeStr);
            //不支持的，跳过
            bool bContains = cameraInfo.ContainsKey(typeStr);
            if (!bContains) continue;


            if (typeStr == "CTRL_AE")
            {
                //曝光Toggle
                GameObject toggleObject = Instantiate(togglePrefab, spawnPoint.transform);
                toggleObject.SetActive(true);
                toggleObject.name = typeStr;

                Text labelObj = toggleObject.transform.Find("Label").GetComponent<Text>();
                labelObj.text = sliderNameArray[i];
                Toggle toggle = toggleObject.GetComponent<Toggle>();
                CTRLAEToggle = toggle;

                UVCCtrlInfo _AEInfo = cameraInfo.GetInfo(typeStr);
                Debug.Log("UVCCtrlInfo:" + _AEInfo.ToString());

                int _currentValue = cameraInfo.GetValue(typeStr);
                bAutoAE = _currentValue == 8 ? true : false; //如果当前值是 8，则当前摄像机是自动曝光模式
                toggle.isOn = bAutoAE;
                //cameraInfo.SetValue(_VALUE, _currentValue!=8? 8:1);

                toggle.onValueChanged.AddListener((bool bValue) =>
                {
                    //Debug.Log("Toggle value changed to: " + bValue + " from " + _VALUE);
                    if (typeStr == "CTRL_AE")
                    {
                        //开关控制是否自动曝光
                        bAutoAE = bValue;
                        if (CTRLAEABSSlider) CTRLAEABSSlider.interactable = !bAutoAE;
                        int _value = bValue ? 8 : 1;
                        //Debug.Log("_value " + _value);
                        cameraInfo.SetValue(typeStr, _value);
                    }

                });
            }
            else
            {
                //其余使用slider
                GameObject sliderObject = Instantiate(sliderPrefab, spawnPoint.transform);
                sliderObject.SetActive(true);
                sliderObject.name = typeStr;

                Slider slider = sliderObject.GetComponent<Slider>();



                Text textObj = sliderObject.transform.Find("text").GetComponent<Text>();
                Text titleTextObj = sliderObject.transform.Find("title").GetComponent<Text>();
                titleTextObj.text = sliderNameArray[i];//类型名字
                if (slider != null)
                {

                    UVCCtrlInfo _UVCCtrlInfo = cameraInfo.GetInfo(typeStr);
                    slider.minValue = _UVCCtrlInfo.min;
                    slider.maxValue = _UVCCtrlInfo.max;
                    slider.wholeNumbers = true;

                    int _defValue = _UVCCtrlInfo.def;
                    //指定默认值
                    //5、UVC亮度 - 50
                    //6、UVC对比度 - 50
                    if (typeStr == "PU_BRIGHTNESS") {
                        _defValue = 50;
                    } else if (typeStr == "PU_CONTRAST") {
                        _defValue = 50;
                    }

                    //记录一个typeStr类型的数据存储操作对象
                    ParamFloatValue paramFloatValue = new ParamFloatValue("ic_uvc_" + typeStr, _defValue);
                    if (typeStr == "PU_BRIGHTNESS" || typeStr == "PU_CONTRAST")
                    {
                        //获取设置默认存储的值
                        int _Value = (int)paramFloatValue.Get();
                        cameraInfo.SetValue(typeStr, _Value);
                        Debug.Log("[InfraredDemo] UVC 设置" + typeStr + "默认值：" + _Value);
                        slider.value = _Value;
                        textObj.text = _Value + "";
                    }
                    else {
                        //获取设置当前值
                        int _currentValue = cameraInfo.GetValue(typeStr);
                        slider.value = _currentValue;
                        textObj.text = _currentValue + "";
                    }
                

                    //如果是曝光slider
                    if (typeStr == "CTRL_AE_ABS")
                    {
                        CTRLAEABSSlider = slider;
                        slider.interactable = !bAutoAE;
                    } 
                    slider.onValueChanged.AddListener((newValue) =>
                    {
                        var _value = Mathf.FloorToInt(newValue);
                        textObj.text = _value + "";
                        //Debug.Log("Slider value changed to: " + newValue + " from " + _VALUE);
                        cameraInfo.SetValue(typeStr, _value);

                    });
                }
            }

        }

    }

    public void OpenUVCPanel()
    {
        _cameraParameterPanel.SetActive(true);
    }

    public void CloseUVCPanel()
    {
        _cameraParameterPanel.SetActive(false);
    }

    public void onResetUVCData()
    {

#if UNITY_ANDROID
        resetUVCData();
#endif

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
        resetPCData();
#endif

    }

    void resetUVCData() {
        if (currentCameraInfo == null) return;

        for (int i = 0; i < sliderStrArray.Length; i++)
        {
            string typeStr = sliderStrArray[i];
           // UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
            bool bContains = currentCameraInfo.ContainsKey(typeStr);
            if (!bContains) continue;

            if (typeStr == "CTRL_AE")
            {
                //toggle值不进行重置
                Debug.Log("CTRL_AE 不需要重置");
            }
            else if (typeStr == "CTRL_AE_ABS")
            {
                if (!bAutoAE)
                {
                    //如果是手动曝光，重置值
                    Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                    Slider slider = trans.GetComponent<Slider>();
                    Text textObj = trans.Find("text").GetComponent<Text>();
                    UVCCtrlInfo _AEInfo = currentCameraInfo.GetInfo(typeStr);
                    //获取当前值
                    int _currentValue = currentCameraInfo.GetValue(typeStr);
                    Debug.Log("CTRL_AE_ABS:" + _currentValue + " = " + _AEInfo.def + " = " + ",bAutoAE:" + bAutoAE);
                    textObj.text = _AEInfo.def + "";
                    slider.value = _AEInfo.def;
                    if (_AEInfo.def != _currentValue) currentCameraInfo.SetValue(typeStr, _AEInfo.def);
                }
            }
            else
            {
                Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                Slider slider = trans.GetComponent<Slider>();
                Text textObj = trans.Find("text").GetComponent<Text>();
                UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
                //重置的值
                int _defValue = _UVCCtrlInfo.def;
                if (typeStr == "PU_BRIGHTNESS")
                {
                    _defValue = 50;
                }
                else if (typeStr == "PU_CONTRAST")
                {
                    _defValue = 50;
                }
                textObj.text = _defValue + "";
                slider.value = _defValue;
                //获取当前值
                int _currentValue = currentCameraInfo.GetValue(typeStr);
                //重置存储值
                //dUVCParameters.GetValueOrDefault(typeStr).Set(_UVCCtrlInfo.def);
                //存储初始值，设置一次到UVC参数
                if (_defValue != _currentValue) currentCameraInfo.SetValue(typeStr, _defValue);
            }
        }
    }


    //windows 相机
    string[] sliderNameArrayPC = new string[]{
        "亮度", 
        "对比度",};
    string[] sliderStrArrayPC = new string[]{
        "PU_BRIGHTNESS",
        "PU_CONTRAST"};
    //记录一个typeStr类型的数据存储操作对象
    ParamFloatValue pcBRIGHTNESS = new ParamFloatValue("ic_pc_PU_BRIGHTNESS", 0);
    ParamFloatValue pcCONTRAST = new ParamFloatValue("ic_pc_PU_CONTRAST", 0);
    public void initSliderPC()
    {
        for (int i = 0; i < sliderStrArrayPC.Length; i++)
        {
            string typeStr = sliderStrArrayPC[i];
            GameObject sliderObject = Instantiate(sliderPrefab, spawnPoint.transform);
            sliderObject.SetActive(true);
            sliderObject.name = typeStr;

            Slider slider = sliderObject.GetComponent<Slider>();
            Text textObj = sliderObject.transform.Find("text").GetComponent<Text>();
            Text titleTextObj = sliderObject.transform.Find("title").GetComponent<Text>();
            titleTextObj.text = sliderNameArrayPC[i];//类型名字
            if (slider != null)
            {
                slider.minValue = -1;
                slider.maxValue = 1;
                //记录一个typeStr类型的数据存储操作对象
                if (typeStr == "PU_BRIGHTNESS")
                {
                    //获取设置默认存储的值
                    float _Value = pcBRIGHTNESS.Get();
                    infraredCameraHelper.SetBrightness(_Value);
                    Debug.Log("[InfraredDemo] PC 设置 PU_BRIGHTNESS:" + typeStr + "默认值：" + _Value);
                    slider.value = _Value;
                    textObj.text = _Value + "";
                    slider.onValueChanged.AddListener((newValue) =>
                    {
                        var _value = newValue;
                        textObj.text = _value + "";
                        infraredCameraHelper.SetBrightness(_value);
                        pcBRIGHTNESS.Set(_value);
                    });
                }
                else if (typeStr == "PU_CONTRAST")
                {
                    //获取设置默认存储的值
                    float _Value = pcCONTRAST.Get();
                    infraredCameraHelper.SetContrast(_Value);
                    Debug.Log("[InfraredDemo] PC 设置 PU_CONTRAST:" + typeStr + "默认值：" + _Value);
                    slider.value = _Value;
                    textObj.text = _Value + "";
                    slider.onValueChanged.AddListener((newValue) =>
                    {
                        var _value = newValue;
                        textObj.text = _value + "";
                        infraredCameraHelper.SetContrast(_value);
                        pcCONTRAST.Set(_value);
                    });
                }
               
            }

        }
    }

    void resetPCData() {
        for (int i = 0; i < sliderStrArrayPC.Length; i++)
        {
            string typeStr = sliderStrArrayPC[i];

            Transform trans = _cameraParameterPanel.transform.Find(typeStr);
            Slider slider = trans.GetComponent<Slider>();
            Text textObj = trans.Find("text").GetComponent<Text>();
            //重置的值
            int _defValue = 0;
            if (typeStr == "PU_BRIGHTNESS")
            {
                _defValue = 0;
                infraredCameraHelper.SetBrightness(_defValue);
            }
            else if (typeStr == "PU_CONTRAST")
            {
                _defValue = 0;
                infraredCameraHelper.SetContrast(_defValue);
            }
            textObj.text = _defValue + "";
            slider.value = _defValue;
        }
    }

   #endregion
    void InitInfraredCamera()
    {
        if (_inited) return;
        _inited = true;
        //SDK创建
        if (infraredCameraHelper == null)
        {
            infraredCameraHelper = InfraredCameraHelper.GetInstance();

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
            infraredCameraHelper.CreateToPc();
#endif
#if UNITY_ANDROID
            //开始时候设置一个默认分辨率
            Debug.Log("开始时候的分辨率下标：" + resoution.Get());
            Vector2 resoutionVec2 = SetDefByIndex((int)resoution.Get());
            infraredCameraHelper.Create((int)resoutionVec2.x, (int)resoutionVec2.y);
#endif


            infraredCameraHelper.OnPositionUpdate += (Vector2 point) =>
            {
                //跑九轴时候，不处理这里位置
                if (AimHandler.ins && AimHandler.ins.bRuning9Axis()) return;
                if (Camera.main == null) return;

                Ray ray = Camera.main.ScreenPointToRay(point);
                Vector3 rayEndPoint = ray.GetPoint(200);
                Quaternion quat = Quaternion.LookRotation(rayEndPoint - Camera.main.transform.position);
                // 挑战场景中其相机的父级有旋转，需要换算
                if (UnityEngine.SceneManagement.SceneManager.GetActiveScene().name == "GameChallenge")
                {
                    quat = Quaternion.AngleAxis(-180, Vector3.up) * quat;
                }
                if (CameraToLook.ins != null) CameraToLook.ins.localRotation = quat;
                if (SB_EventSystem.ins) SB_EventSystem.ins.MoveSimulateMouseByInfrared(point);
                //移动目标游戏
                if(GeneratingTarget.gm!=null)  GeneratingTarget.gm.shootingEvent.OnPositionUpdate(point);
            };
            infraredCameraHelper.OnUVCIsReady += (UVCManager.CameraInfo camera) =>
            {
                //生成控制摄像机的参数滑条
                Debug.Log("初始化摄像机！");
                //可以操作按钮
                mBtnSee.interactable = true;
                mBtnSee.transform.Find("Text").GetComponent<Text>().text = "调试红外";
                //延迟重新设置一次分辨率
                StartCoroutine(delayInitOhterInfo(camera));
               
            };

            //屏幕变化时候
            infraredCameraHelper.OnUVCPosUpdate += (list) =>
            {
                Debug.Log("OnUVCPosUpdate");
                 SetLocatePointsToCameraRender(list, 1, 1);
                //InfraredScreenPositioningView 页面
                if (list.Count == 4)
                {
                    FindObjectOfType<InfraredScreenPositioningView>()?.SyncScreenPosition();
                }
                else {
                    FindObjectOfType<InfraredScreenPositioningView>()?.onReset();
                }
            };
        }
    }
    /// <summary>
    /// 初始化一些游戏配置
    /// </summary>
    /// <returns></returns>
    IEnumerator delayInitOhterInfo(UVCManager.CameraInfo camera) {

        //yield return new WaitForSeconds(1f);
        yield return new WaitForEndOfFrame();
#if UNITY_ANDROID
        initSlider(camera);

        camera.GetResolutionsStrs();
        // 清除默认选项
        _dropdownResolution2.ClearOptions();
        // 将分辨率字符串数组转换为 Dropdown 选项
        _dropdownResolution2.AddOptions(new List<string>(resolutions));
        // 默认设置
        int index = (int)resoution.Get();
        _dropdownResolution2.value = index;
        _dropdownResolution2.RefreshShownValue();
        // 处理 Dropdown 的选择变化
        _dropdownResolution2.onValueChanged.AddListener(index => { OnResolutionChanged(index);});
#endif

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
        initSliderPC();
        //隐藏不需要的设置
        _btnAdjusting.transform.Find("Text").GetComponent<Text>().text = "调整PC参数";
        _dropdownResolution.gameObject.SetActive(false);
        _dropdownResolution2.gameObject.SetActive(false);
    
#endif

        //震动阈值
        SetShakeFilterValue(shakeFilterValue.Get());
        _sliderShakeFilter.onValueChanged.AddListener(SetShakeFilterValue);
        //功能按钮
        //重置触发测试
        _btnReset.onClick.AddListener(OnClick_Reset);
        _btnScreenLocateManual.onClick.AddListener(OnClick_ScreenLocateManual);
        _btnScreenLocateManualAuto.onClick.AddListener(OnClick_ScreenLocateManualAuto);

        SetCaptureValue(captureValue.Get());
        _sliderCapture.onValueChanged.AddListener(SetCaptureValue);
        SetDelayValue(delayValue.Get());
        _sliderDelay.onValueChanged.AddListener(SetDelayValue);

       

        //绘制线段
        SetLineWidth(lineWidth.Get());
        _sliderLineWidth.onValueChanged.AddListener(SetLineWidth);

        //检测红外亮度阈值
        SetInfraredFilterValue(infraredFileterValue.Get());
        _infraredFilter.onValueChanged.AddListener(SetInfraredFilterValue);

        //野鸭设置初始关卡
        int defLevel = (int)duckHunterLevel.Get() - 1 < 0 ? 0 : (int)duckHunterLevel.Get() - 1;
        _duckLevelDropdown.SetValueWithoutNotify(defLevel);
        _duckLevelDropdown.onValueChanged.AddListener(SetDuckLevelTest);

    }


    /// <summary>
    /// 初始化时候获取设置和存储来控制显示准心
    /// </summary>
    /// <returns></returns>
    public bool bInitCrosshairShow() {
       return UserSettings.ins.openCrossHair && getCrosshairValue() == 1 ? true : false;
    }

    /// <summary>
    /// 获取弓箭准心存储值 
    /// </summary>
    /// <returns></returns>
    public int getCrosshairValue() {
       return (int)crosshairValue.Get();
    }

    public void setCrosshairValue(bool bshow) {
        crosshairValue.Set(bshow?1:0);
    }

    public void onStartPreview()
    {
        infraredCameraHelper.onStartPreview();
    }
    public void onStopPreview()
    {
        infraredCameraHelper.onStopPreview();
    }
    /// <summary>
    /// 获取并且初始化一次记录点的数据
    /// </summary>
    /// <returns></returns>
    IEnumerator initScreenLocateManual()
    {
        yield return new WaitForSeconds(1f);
        infraredCameraHelper.InitScreenLocateManual();
    }

    IEnumerator RestartOrKillApp()
    {
        yield return new WaitForSeconds(0.3f);
        if (Application.isEditor) yield break;
        if (Application.platform == RuntimePlatform.Android)
        {
            using (var unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
            {
                const int kIntent_FLAG_ACTIVITY_CLEAR_TASK = 0x00008000;
                const int kIntent_FLAG_ACTIVITY_NEW_TASK = 0x10000000;
                var currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
                var pm = currentActivity.Call<AndroidJavaObject>("getPackageManager");
                var intent = pm.Call<AndroidJavaObject>("getLaunchIntentForPackage", Application.identifier);
                intent.Call<AndroidJavaObject>("setFlags", kIntent_FLAG_ACTIVITY_NEW_TASK | kIntent_FLAG_ACTIVITY_CLEAR_TASK);
                currentActivity.Call("startActivity", intent);
                currentActivity.Call("finish");
                var process = new AndroidJavaClass("android.os.Process");
                int pid = process.CallStatic<int>("myPid");
                process.CallStatic("killProcess", pid);
            }
        }
        else {
            // 获取当前应用程序的可执行文件路径
            string executablePath = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;

            // 重启应用程序
            System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo
            {
                FileName = executablePath,
                UseShellExecute = false
            };
            System.Diagnostics.Process.Start(startInfo);

            // 退出当前应用程序
            Application.Quit();
        };
    }

    void UpdateInfraredCamera()
    {
        if (!_visiable) return;
        if (!_inited) return;
        if (infraredCameraHelper == null) return;
        //渲染相机画面
        //_cameraRender.texture = infraredCameraHelper.GetCameraTexture();
        //_cameraRender.material = infraredCameraHelper.GetCameraMaterial();
        if (ScreenLocate.Main.getUVCTexture)
        {
            if(_cameraRender.texture ==null || ScreenLocate.Main.getUVCTexture.GetNativeTexturePtr() != _cameraRender.texture.GetNativeTexturePtr())
               _cameraRender.texture = ScreenLocate.Main.getUVCTexture;
            //_cameraRender.SetNativeSize();
            // _MaintainAspectRatio.AdjustSize();
        }
        //在相机画面显示准心
        if (ScreenLocate.Main)
        {
            var _sl = ScreenLocate.Main;
            var buffer = _sl.infraredSpotBuffer;
            if (buffer != null)
            {
                for (int i = 0; i < buffer.Length; i++)
                {
                    if (buffer[i].CameraLocation != null)
                    {
                        //添加一个偏移量，使得最后输出的准心是指向正中心
                        Vector2 newPoint2 = _sl.GetOffsetCameraLocation(buffer[i].CameraLocation.Value);
                        // 检测到光点 
                        var pos = newPoint2.pixelToLocalPosition_AnchorCenter(_sl.mUVCCameraInfo.Size, _cameraRender.rectTransform.rect);
                        _crosshairsInCamera[i].gameObject.SetActive(true);
                        _crosshairsInCamera[i].anchoredPosition = pos;

                    }
                    else
                        _crosshairsInCamera[i].gameObject.SetActive(false);
                }
            }
            //渲染固定摄像机分辨率
            SetCalibrationFixedText(_sl.mUVCCameraInfo.CurrentCalibrationResolution);
            //渲染摄像机大小
            if(_sl.mUVCCameraInfo != null) SetCameraSizeText(_sl.mUVCCameraInfo.Size);
            //渲染摄像机识别点位置
            SetQuadUnityVectorListText(_sl.PrintVector2List(ScreenLocate.quadUnityVectorList));

        }
    }

    public void SetLocatePointsToCameraRender(List<Vector2> points, float w, float h)
    {
        Transform pointsTF2 = _cameraRender.transform.Find("Points");

        if (pointsTF2.childCount == points.Count)
        {
            Vector2 texSize = new Vector2(w, h);
            for (int i = 0; i < pointsTF2.childCount; i++)
            {
                Transform pointTF = pointsTF2.GetChild(i);
                Vector2 pos = points[i];
                pointTF.localPosition = pos.pixelToLocalPosition_AnchorCenter(texSize, _cameraRender.rectTransform.rect);
                pointTF.gameObject.SetActive(true);
            }
        }
        else {
            for (int i = 0; i < pointsTF2.childCount; i++)
            {
                Transform pointTF = pointsTF2.GetChild(i);
                pointTF.gameObject.SetActive(false);
            }
        }
    }

    public void SetLocatePointsToCameraRenderTest(List<Vector2> points, float w, float h)
    {
        Transform pointsTF2 = _cameraRender.transform.Find("PointsTest");

        if (pointsTF2.childCount == points.Count)
        {
            Vector2 texSize = new Vector2(w, h);
            for (int i = 0; i < pointsTF2.childCount; i++)
            {
                Transform pointTF = pointsTF2.GetChild(i);
                Vector2 pos = points[i];
                pointTF.localPosition = pos.pixelToLocalPosition_AnchorCenter(texSize, _cameraRender.rectTransform.rect);
                pointTF.gameObject.SetActive(true);
            }
        }
        else
        {
            for (int i = 0; i < pointsTF2.childCount; i++)
            {
                Transform pointTF = pointsTF2.GetChild(i);
                pointTF.gameObject.SetActive(false);
            }
        }
    }

    void SetShakeFilterValue(float v)
    {
        shakeFilterValue.Set(v);
        _sliderShakeFilter.SetValueWithoutNotify(shakeFilterValue.Get());
        _sliderShakeFilter.transform.Find("Value").GetComponent<Text>().text = shakeFilterValue.Get().ToString("f1");
        infraredCameraHelper.SetShakeFilterValue(shakeFilterValue.Get());
    }

    /// <summary>
    /// 重新设置分辨率
    /// </summary>
    /// <param name="index"></param>
    public void resolutionRestartApp(int index)
    {
#if UNITY_ANDROID
        //StartCoroutine(RestartOrKillApp());
        //获取第一个分辨率设置后设置size
        switch (index)
        {
            case 0:
                infraredCameraHelper.SetHighCameraResolution();
                resoution.Set(index);
                _dropdownResolution2.SetValueWithoutNotify(index);
                break;
            case 1:
                infraredCameraHelper.SetLowCameraResolution();
                resoution.Set(index);
                _dropdownResolution2.SetValueWithoutNotify(index);
                break;
        }
#endif

    }

    /// <summary>
    /// 初始化时候，设置的值
    /// </summary>
    /// <param name="index"></param>
    public Vector2 SetDefByIndex(int index = 0)
    {
        //SetResolutionNew 里面对应的下标
        Vector2 vec2 = new Vector2(320, 240);
        switch (index)
        {
            case 0:
                vec2 = new Vector2(320, 240);
                break;
            case 1:
                vec2 = new Vector2(160, 120);
                break;
        }
        return vec2;
    }
    /// <summary>
    /// 当 Dropdown 选择变化时的处理方法
    /// </summary>
    /// <param name="OnResolutionChanged">320x240</param>
    private void OnResolutionChanged(int index)
    {
#if UNITY_ANDROID
        Debug.Log("Selected Resolution: " + index);
        // 将选定的分辨率转换为实际的宽度和高度
        // 并且需要判断是否存在最低分辨率
        if (index == 1 && currentCameraInfo.ContainsResulutionKey("160x120"))
        {
            // 在这里你可以根据实际需要设置屏幕分辨率或进行其他操作
            infraredCameraHelper.SetLowCameraResolution();
            // 保存选择的分辨率到 PlayerPrefs
            resoution.Set(index);
        }
        else if(index == 0){
            //如果是0就 使用高分辨率
            infraredCameraHelper.SetHighCameraResolution();
            // 保存选择的分辨率到 PlayerPrefs
            resoution.Set(index);
        }
#endif
    }

    /// <summary>
    /// 野鸭关卡测试初始值
    /// </summary>
    /// <param name="optionIndex"></param>
    public void SetDuckLevelTest(int optionIndex)
    {
        //选择下标+1
        int v = optionIndex + 1;
        duckHunterLevel.Set(v);
        _sliderLineWidth.SetValueWithoutNotify(duckHunterLevel.Get());
        _sliderLineWidth.transform.Find("Value").GetComponent<Text>().text = duckHunterLevel.Get().ToString("f1");
    }

    void OnClick_Reset()
    {
        //SetBrightness(1);
        //SetSaturation(1);
        //SetContrast(1);

        SetShakeFilterValue(6);
        SetLineWidth(10);
        SetInfraredFilterValue(0.8f);
        SetCaptureValue(30.0f);
        SetDelayValue(30.0f);

        //重置为第一关
        SetDuckLevelTest(0);
    }

    public void OnClickClearAll() {
        PlayerPrefs.DeleteAll();
        // 保存更改
        PlayerPrefs.Save();

        StartCoroutine(RestartOrKillApp());

    }
    void OnClick_ScreenLocateManual()
    {
        ViewManager2.ShowView(ViewManager2.Path_InfraredScreenPositioningView);
        FindObjectOfType<InfraredScreenPositioningView>().enterFromInfraredDemo = true;
    }

    void OnClick_ScreenLocateManualAuto()
    {
        infraredCameraHelper.EnterScreenLocateManualAuto();
    }

   public void OnClick_SetAdjustPointsOffset()
    {
        var _sl = ScreenLocate.Main;
        var buffer = _sl.infraredSpotBuffer;
        if (buffer != null)
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                if (buffer[i].CameraLocation != null)
                {
                    Debug.Log("CameraLocation:"+buffer[i].CameraLocation.Value);
                    var centerOffset = infraredCameraHelper.GetCenterOffset(buffer[i].CameraLocation.Value, "CameraLocation");
                    Debug.Log("CenterOffset: " + centerOffset);
                    var uvCenterOffset  = infraredCameraHelper.GetCenterOffset(buffer[i].ScreenUV.Value, "ScreenUV");
                    Debug.Log("UvCenterOffset: " + uvCenterOffset);
                    //如果是新手教程场景里面的校准
                    InfraredGuider infraredGuiderObj = FindObjectOfType<InfraredGuider>();
                    if (infraredGuiderObj != null)
                    {
                        GameObject infraredGuiderGameObject = infraredGuiderObj.gameObject;
                        infraredGuiderGameObject.GetComponent<InfraredGuider>().SetTitleAfterCalibration();
                    }
                }
            }
        }


    }
    /// <summary>
    /// 重置中心点
    /// </summary>
    public void ResetCenterOffset() {
        infraredCameraHelper.ResetCenterOffset();
    }



    void SetCaptureValue(float v)
    {
        captureValue.Set(v);
        _sliderCapture.SetValueWithoutNotify(captureValue.Get());
        _sliderCapture.transform.Find("Value").GetComponent<Text>().text = captureValue.Get().ToString("f1");
        infraredCameraHelper.SetCapture((int)captureValue.Get());
    }
    void SetDelayValue(float v)
    {
        delayValue.Set(v);
        _sliderDelay.SetValueWithoutNotify(delayValue.Get());
        _sliderDelay.transform.Find("Value").GetComponent<Text>().text = delayValue.Get().ToString("f1");
        infraredCameraHelper.SetDelay((int)delayValue.Get());
    }
    #endregion


    #region 相机感光度(默认修改对比度)
    public void onSetSliderCustomValue(Slider _slider, float min = 0.0f, float max = 10.0f)
    {
        onSetSliderValue(_slider, "PU_CONTRAST", min, max);
    }
    public void onSliderCustomEvent(float value, float min = 0.0f, float max = 10.0f)
    {
        onSliderEvent(value, "PU_CONTRAST", min, max);
    }
    public void onSetSliderValue(Slider _slider,string typeStr = "PU_CONTRAST", float min = 0.0f, float max = 10.0f)
    {
        if (BluetoothWindows.IsWindows()) {
            float v = typeStr == "PU_CONTRAST"?infraredCameraHelper.GetContrast(): infraredCameraHelper.GetBrightness();
            // 目标区间 [0, 10] 的边界值
            double targetMin = min;
            double targetMax = max;
            double originalMin = -1;
            double originalMax = 1;
            // 计算转换后的值
            double v2 = MapValue(v, originalMin, originalMax, targetMin, targetMax);

            Debug.Log("PC获取相机的感光度 "+ typeStr + " ：" + v + " = " + v2);
            _slider.SetValueWithoutNotify((float)v2);
            return;
        }
        //功能也改为UVC的对比度
        if (running)
        {
            //string typeStr = "PU_CONTRAST";//"PU_BRIGHTNESS";
            //UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
            UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
            float v = currentCameraInfo.GetValue(typeStr); // infraredCameraHelper.GetBrightness();
            //float v2 = (v / _UVCCtrlInfo.max) * 10;

            // 目标区间 [0, 10] 的边界值
            double targetMin = 0.0;
            double targetMax = 10.0;
            double originalMin = _UVCCtrlInfo.min;
            double originalMax = _UVCCtrlInfo.max;
            // 计算转换后的值
            double v2 = MapValue(v, originalMin, originalMax, targetMin, targetMax);


            Debug.Log("获取相机的感光度" + typeStr + "： " + v + " = " + v2);
            _slider.SetValueWithoutNotify((float)v2);
        }
        else _slider.SetValueWithoutNotify(5);
    }
   
    public void onSliderEvent(float value, string typeStr = "PU_CONTRAST", float min = 0.0f,float max = 10.0f)
    {
       // string typeStr = "PU_CONTRAST";// "PU_BRIGHTNESS";
        //pc
        if (BluetoothWindows.IsWindows())
        {
            Transform trans = _cameraParameterPanel.transform.Find(typeStr);
            Slider slider = trans.GetComponent<Slider>();
            Text textObj = trans.Find("text").GetComponent<Text>();
            // 原始区间和目标区间的边界值
            double originalMin = min;
            double originalMax = max;
            double targetMin = -1;
            double targetMax = 1;
            // 计算转换后的值
            double result = MapValue(value, originalMin, originalMax, targetMin, targetMax);

            float _current = (float)result;
            //Debug.Log("_current:" + _current + " , result:" + result);
            textObj.text = _current + "";
            slider.value = _current;
            if (typeStr == "PU_CONTRAST")
            {
                infraredCameraHelper.SetContrast(_current);
                pcCONTRAST.Set(_current);
            }
            else {
                infraredCameraHelper.SetBrightness(_current);
                pcBRIGHTNESS.Set(_current);
            }

            return;
        }

        //修改亮度时，调试界面的亮度也应该一起修改
        //功能也改为UVC的对比度
        if (running)
        {
            //Slider slider = transform.Find("InfraredCamera/Layout/SliderBrightness")
            //    .GetComponent<Slider>();

           // UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
            Transform trans = _cameraParameterPanel.transform.Find(typeStr);
            Slider slider = trans.GetComponent<Slider>();

            Text textObj = trans.Find("text").GetComponent<Text>();
            UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
            int _currentUVCValue = currentCameraInfo.GetValue(typeStr);
            //value 0 ~ 10
            // 原始区间和目标区间的边界值
            double originalMin = min;
            double originalMax = max;
            double targetMin = _UVCCtrlInfo.min;
            double targetMax = _UVCCtrlInfo.max;
            // 计算转换后的值
            double result = MapValue(value, originalMin, originalMax, targetMin, targetMax);

            int _current = (int)(result);
            Debug.Log("_current:" + value + " , result:" + result);
            textObj.text = _current + "";
            slider.value = _current;
            //dUVCParameters.GetValueOrDefault(typeStr).Set(_current);
            //存储初始值，设置一次到UVC参数
            if (_currentUVCValue != _current) currentCameraInfo.SetValue(typeStr, _current);

        }
    }

    public static double MapValue(double value, double originalMin, double originalMax, double targetMin, double targetMax)
    {
        // 线性插值公式
        return targetMin + (value - originalMin) * (targetMax - targetMin) / (originalMax - originalMin);
    }
#endregion


#region 绘制线段部分
    public void SetLineWidth(float v)
    {
        lineWidth.Set(v);
        _sliderLineWidth.SetValueWithoutNotify(lineWidth.Get());
        _sliderLineWidth.transform.Find("Value").GetComponent<Text>().text = lineWidth.Get().ToString("f1");
    }
#endregion
#region 亮度检测部分
    public void SetInfraredFilterValue(float v)
    {
        infraredFileterValue.Set(v);
        _infraredFilter.SetValueWithoutNotify(infraredFileterValue.Get());
        _infraredFilter.transform.Find("Value").GetComponent<Text>().text = infraredFileterValue.Get().ToString("f1");
        infraredCameraHelper.SetInfraredLocateBrightnessThreshold(infraredFileterValue.Get());
    }
#endregion
    public void resetInfraredPlayerPrefs()
    {
        //测试用
        PlayerPrefs.DeleteKey("entry-guider-infrared-" + LoginMgr.myUserInfo.id);
        PlayerPrefs.DeleteKey("hideInfraredBowAndArrow");
    }

#region 显示Log部分信息

    [SerializeField] Text _calibrationFixedText;
    [SerializeField] Text _cameraSizeText;
    [SerializeField] Text _quadUnityVectorListText;
    /// <summary>
    /// 校准时候的固定值分辨率
    /// </summary>
    /// <param name="v"></param>
    public void SetCalibrationFixedText(Vector2 v)
    {
        _calibrationFixedText.text = v.x + "*" + v.y;
    }
    /// <summary>
    /// 渲染摄像机当前分辨率
    /// </summary>
    /// <param name="v"></param>
    public void SetCameraSizeText(Vector2 v)
    {
        _cameraSizeText.text = v.x + "*" + v.y;
    }
    /// <summary>
    /// 渲染摄像机识别点
    /// </summary>
    /// <param name="v"></param>
    public void SetQuadUnityVectorListText(string v)
    {
        _quadUnityVectorListText.text = v;
    }
    #endregion

}
public class ParamFloatValue
{
    private string _saveKey;
    private float _valueDefault;
    private bool _valueLoaded;
    private float _value;
    public ParamFloatValue(string saveKey, float valueDefault)
    {
        _saveKey = saveKey;
        _valueDefault = valueDefault;
    }
    public float Get()
    {
        if (!_valueLoaded) _value = PlayerPrefs.GetFloat(_saveKey, _valueDefault);
        return _value;
    }
    public void Set(float value)
    {
        _value = value;
        PlayerPrefs.SetFloat(_saveKey, _value);
        PlayerPrefs.Save();
    }
}