Kyungshin-Welder/AuroraVision/VisionUI/Setup/AutoFocus/AutoFocusViewModel.cs

/*
  * Copyright (c) 2025 LG Electronics Inc.
   * SPDX-License-Identifier: LicenseRef-LGE-Proprietary
   */
using Aurora;
using System.Reactive.Linq;
using System;
using System.Windows;
using Aurora.Api;
using System.Collections.ObjectModel;
using System.Windows.Input;
using Aurora.View;
using VisionCommon;
using VisionSequence.Setup;
using VisionCommonUI;
using VisionCommonUI.Resources;
using Aurora.Util.HislogPlus;
using System.Collections.Generic;

namespace VisionUI.Setup {
    /// <summary>
    /// 오토 포커스 뷰 모델
    /// </summary>
    public class AutoFocusViewModel : Aurora.View.NotifyPropertyChangedBase, IUpdateRecipe {
        private Logger _Logger;
        private ISequence _Seq;

        private FovInfo _FovInfo;
        private FovRecipe _FovRecipe;
        private CsvManager _CsvManager = new CsvManager();

        #region Binding Properties
        /// <summary>오토포커스 로그 아이템 컬렉션</summary>
        public ObservableCollection<AutoFocusLog> AutoFocusLogItems { get; set; } = new ObservableCollection<AutoFocusLog>();
        /// <summary>오토포커스 로그 아이템 컬렉션(Roughly)</summary>
        public ObservableCollection<AutoFocusLog> AutoFocusLogItems_Roughly { get; set; } = new ObservableCollection<AutoFocusLog>();
        /// <summary>오토포커스 로그 아이템 컬렉션(Delicately)</summary>
        public ObservableCollection<AutoFocusLog> AutoFocusLogItems_Delicately { get; set; } = new ObservableCollection<AutoFocusLog>();

        private AutoFocusRecipe _AutoFocusRecipe;
        /// <summary>오토포커스 레시피</summary>
        public AutoFocusRecipe AutoFocusRecipe { get => _AutoFocusRecipe; set => SetProperty(ref _AutoFocusRecipe, value); }

        private DateTime selectedDate;

        /// <summary>선택된 날짜</summary>
        public DateTime SelectedDate { get => selectedDate; set { SetProperty(ref selectedDate, value); CalendarChanged(value); } }
        #endregion

        #region Button Commands
        public ICommand ButtonCommandSetFindRoi { get; set; }
        public ICommand ButtonCommandStart { get; set; }
        public ICommand ButtonCommandCancel { get; set; }
        public ICommand ButtonCommandSaveParams { get; set; }
        #endregion
        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="fovInfo">Fov 정보</param>
        public AutoFocusViewModel(FovInfo fovInfo) {
            _FovInfo = fovInfo;
            _FovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfo);
            _Logger = new Logger(string.Format("AutoFocusViewModel[{0}]", fovInfo.SubSysName));

            ButtonCommandSetFindRoi = new DelegateCommand(new Action<object>(DoSetFindRoi));
            ButtonCommandStart = new DelegateCommand(new Action<object>(DoStart));
            ButtonCommandCancel = new DelegateCommand(new Action<object>(DoCancel));
            ButtonCommandSaveParams = new DelegateCommand(new Action<object>(DoSaveParams));
            SelectedDate = DateTime.Now.Date;

            UpdateRecipeFromFile();
            SetObservable();
        }

        private void SetObservable() {
            var disposable_1 = VisionEnv.AuroraEnv.EventObservable.AsObservable(VisionEventId.CLEAR_AUTO_FOCUS_LOG).
                Where(x => x.From == _FovInfo.GetKey()).Subscribe(_ => ClearAutoFocusLog());
            DisposableManager.AddDisposable(eDpsGroupKey.SubMenu_AutoFocus, disposable_1);

            var disposable_2 = VisionEnv.AuroraEnv.EventObservable.AsObservable(VisionEventId.UPDATE_AUTO_FOCUS_LOG).
                Where(x => x.From == _FovInfo.GetKey()).Subscribe(autoFocusLog => UpdateAutoFocusLog(autoFocusLog));
            DisposableManager.AddDisposable(eDpsGroupKey.SubMenu_AutoFocus, disposable_2);
        }
        /// <summary>
        /// 오토포커스 로그 클리어
        /// </summary>
        public void ClearAutoFocusLog() {
            Application.Current.Dispatcher.BeginInvoke(
                new Action(() => {
                    AutoFocusLogItems.Clear();
                    AutoFocusLogItems_Roughly.Clear();
                    AutoFocusLogItems_Delicately.Clear();
                }));
        }
        /// <summary>
        /// 오토포커스 로그 업데이트
        /// </summary>
        /// <param name="msg">이벤트 메세지</param>
        public void UpdateAutoFocusLog(EventMessage msg) {
            Application.Current.Dispatcher.BeginInvoke(
                new Action(() => {
                    var log = msg.Param as AutoFocusLog;
                    AutoFocusLogItems.Add(log);
                    if(log.Mode == eFocusMode.Roughly.ToString()) {
                        AutoFocusLogItems_Roughly.Add(log);
                    }
                    else if(log.Mode == eFocusMode.Delicately.ToString()) {
                        AutoFocusLogItems_Delicately.Add(log);
                    }
                }));
        }
        /// <summary>
        /// 찾는 ROI 등록
        /// </summary>
        /// <param name="display">null</param>
        public void DoSetFindRoi(object display = null) {
            AddSharpnessROI();
        }
        /// <summary>
        /// 오토포커스 시퀀스 시작
        /// </summary>
        /// <param name="display">null</param>
        public void DoStart(object display = null) {
            if (AutoFocusRecipe == null) {
                MessageBoxUtil.ShowMessageBoxError(
                    string.Format(StrTokens.MSG_E_AutoFocusRecipeIsNull));
                return;
            }

            AutoFocusLogItems.Clear();
            AutoFocusLogItems_Roughly.Clear();
            AutoFocusLogItems_Delicately.Clear();
            SetSharpnessRoi();
            _Seq = Application.Current.AuroraEnv().SequenceEntry[VisionKeys.AutoFocusSeqKey];
            _Seq?.Start(new SetupSeqParams_AutoFocus(_FovInfo, AutoFocusRecipe), OnCompleted);
        }
        /// <summary>
        /// 선명도 ROI 추가
        /// </summary>
        public void AddSharpnessROI() {
            try {
                if (AutoFocusRecipe == null) {
                    _Logger.FuncW("AutoFocusRecipe is null.");
                    return;
                }

                var cameraDisplay = CameraDisplayManager.GetDisplay(_FovInfo, eDisplayType.AutoFocus);
                cameraDisplay.AddFindRoi(AutoFocusRecipe.SharpnessRoi, false);
            }
            catch (Exception e) {
                _Logger.FuncE("{0}", e.Message);
            }
        }

        private void UpdateSharpnessRoi() {
            var cameraDisplay = CameraDisplayManager.GetDisplay(_FovInfo, eDisplayType.AutoFocus);
            AutoFocusRecipe.SharpnessRoi = cameraDisplay.GetFindRoi();
            AutoFocusRecipe.SharpnessRoi.RoiColor = eColor.Orange;

            if (AutoFocusRecipe.SharpnessRoi.Width == 0 && AutoFocusRecipe.SharpnessRoi.Height == 0) {
                AutoFocusRecipe.SharpnessRoi.CenterX = 1000;
                AutoFocusRecipe.SharpnessRoi.CenterY = 1000;
                AutoFocusRecipe.SharpnessRoi.Width = 200;
                AutoFocusRecipe.SharpnessRoi.Height = 300;
            }

            var autoFocusRecipe = VisionRecipeManager.GetAutoFocusRecipe(_FovInfo);
            AutoFocusRecipe.CopyTo(autoFocusRecipe);
        }

        private void SetSharpnessRoi() {
            var cameraDisplay = CameraDisplayManager.GetDisplay(_FovInfo, eDisplayType.AutoFocus);
            if (!ROI.IsNullOrEmpty(cameraDisplay.GetFindRoi())) {
                AutoFocusRecipe.SharpnessRoi = cameraDisplay.GetFindRoi();
            }
        }
        /// <summary>
        /// 오토포커스 시퀀스 완료후 작업내용 이벤트 핸들러
        /// </summary>
        /// <param name="seqResult">오토포커스 시퀀스 완료 결과</param>
        private void OnCompleted(SequenceActionResult seqResult) {
            UpdateAutoFocusParams(seqResult.Param as SetupSeqResultParams_AutoFocus);
        }
        /// <summary>
        /// 시퀀스 정지
        /// </summary>
        /// <param name="display"></param>
        public void DoCancel(object display = null) {
            _Seq?.Stop();
            //CancelSequence.Invoke(this, new EventArgs());
        }
        /// <summary>
        /// 세이브 파라미터
        /// </summary>
        /// <param name="display">null</param>
        public void DoSaveParams(object display = null) {
            UpdateRecipeFromUI();
            RecipeFileManager.SaveVisionRecipe();
        }
        /// <summary>
        /// 오토포커스 파라미터들 업데이트
        /// 최적의 Step | Sharpness | BestPosZ
        /// </summary>
        /// <param name="autoFocusResult">오토포커스 셋업 시퀀스 결과 파라미터</param>
        public void UpdateAutoFocusParams(SetupSeqResultParams_AutoFocus autoFocusResult) {
            AutoFocusRecipe.BestStep = autoFocusResult.BestStep;
            AutoFocusRecipe.BestSharpness = autoFocusResult.BestSharpness;
            AutoFocusRecipe.BestPos = autoFocusResult.BestPosZ;
        }

        /// <summary>
        /// 현재 시간 기준으로 CSV 불러오기
        /// </summary>
        public void LoadCsvNow() {
            DateTime dateTime = DateTime.Now;
            LoadCsv(dateTime);
        }

        private void CalendarChanged(DateTime dateTime) {
            LoadCsv(dateTime);
        }

        private void LoadCsv(DateTime dateTime) {
            try {
                AutoFocusLogItems.Clear();
                AutoFocusLogItems_Roughly.Clear();
                AutoFocusLogItems_Delicately.Clear();
                List<AutoFocusLog> items = _CsvManager.LoadCsv<AutoFocusLog>(_FovInfo.ToSubSysInfo(), dateTime, eSaveDataType.AutoFocus);
                if (items != null) {
                    foreach (AutoFocusLog item in items) {
                        AutoFocusLogItems.Add(item);
                    }
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
        }

        public void RefreshVisionRecipes() {
            _FovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfo);
            UpdateRecipeFromFile();
        }

        public void UpdateRecipeFromFile() {
            var autoFocusRecipe = VisionRecipeManager.GetAutoFocusRecipe(_FovInfo);
            AutoFocusRecipe = autoFocusRecipe.Clone();
        }

        public void UpdateRecipeFromUI() {
            UpdateSharpnessRoi();
        }
    }
}