LGES-OC5-PtoP-Welder/AuroraVision/VisionSequence/Inspector/InspSeq_PatternExist.cs

using System.Collections.Generic;
using Aurora.Api;
using VisionCommon;
using VisionSequence.Pattern;
using Hermes;
using VisionCommonUI;
using VisionCommonUI.Resources;
using VisionSequence.Aligner;

namespace VisionSequence.Inspector {
    /// <summary>
    /// 패턴 유무 검사 시퀀스 파라미터
    /// </summary>
    public class InspSeqParams_PatternExist {
        /// <summary>FOV 키 정보</summary>
        public FovInfo FovInfo { get; set; }
        /// <summary>Align 키 정보</summary>
        public AlignInfo AlignInfo { get; set; }
        /// <summary>메인 화면 타입</summary>
        public eDisplayType DisplayType { get; set; }

        /// <summary>
        /// 생성자
        /// </summary>
        /// <param name="fovInfo">FOV 키 정보</param>
        /// <param name="displayType">메인 화면 타입</param>
        public InspSeqParams_PatternExist(
            FovInfo fovInfo,
            eDisplayType displayType = eDisplayType.Main_1) {
            this.FovInfo = fovInfo;
            this.DisplayType = displayType;
        }
    }

    /// <summary>
    /// 패턴 유무 검사 (서브시퀀스로 호출해서 사용)
    /// </summary>
    public class InspSeq_PatternExist : SubSeqBase {
        private readonly Logger LOG = new Logger(typeof(InspSeq_PatternExist).Name);
        private InspSeqParams_PatternExist _Params;
        private SubSysInfo _SubSysInfo;
        private ImageManager _ImageManager = new ImageManager();
        private PatternAgentBase _PatternAgent;

        private FovRecipe _FovRecipe;
        private AlignInfo _AlignInfo;

        private string _SeqName;

        #region Sequence Id
        private const string SEQ_ID_INIT = "INIT";
        private const string SEQ_ID_CLEAR = "CLEAR";

        // Dry Run
        private const string SEQ_CHECK_DRY_RUN = "CHECK_DRY_RUN";
        private const string SEQ_ID_SET_DRY_RUN_SEQ_PARAMS = "SET_DRY_RUN_SEQ_PARAMS";
        private const string SEQ_ID_DRY_RUN_SEQ = "DRY_RUN_SEQ";

        private const string SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS = "SET_GRAB_FIND_PROC_SEQ_PARAMS";
        private const string SEQ_ID_GRAB_FIND_PROC_SEQ = "GRAB_FIND_PROC_SEQ";
        private const string SEQ_ID_UPDATE_UI = "UPDATE_UI";
        private const string SEQ_ID_SAVE_SCREENSHOT = "SAVE_SCREENSHOT";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

        /// <summary>
        /// 생성자
        /// </summary>
        public InspSeq_PatternExist() {
        }

        private void SetActions(SequenceBuilder sb) {
            SequenceBuilder dryRunSeqBuilder = SubSeqManager.CreateSubSeqBuilder(new AlignSeq_DryRun(), typeof(AlignSeq_DryRun).Name);
            SequenceBuilder grabFindProcSeqBuilder = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), typeof(GrabFindProcSeq).Name);

            sb.AddAction(SEQ_ID_INIT, Init);
            sb.AddAction(SEQ_ID_CLEAR, Clear);

            // Dry Run
            sb.AddDecision(SEQ_CHECK_DRY_RUN, CheckDryRun);
            sb.AddAction(SEQ_ID_SET_DRY_RUN_SEQ_PARAMS, SetDryRunSeqParams);
            sb.AddSubsequence(SEQ_ID_DRY_RUN_SEQ, dryRunSeqBuilder);

            sb.AddAction(SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS, SetGrabFindProcSeqParams);
            sb.AddSubsequence(SEQ_ID_GRAB_FIND_PROC_SEQ, grabFindProcSeqBuilder);
            sb.AddAction(SEQ_ID_UPDATE_UI, UpdateUI);
            sb.AddAction(SEQ_ID_SAVE_SCREENSHOT, SaveScreenShot);
            sb.AddAction(SEQ_ID_SEQ_COMPLETE, SeqComplete);
        }

        public override SequenceBuilder Builder(string seqName) {
            _SeqName = seqName;

            SequenceBuilder sb = new SequenceBuilder(1000);
            SetActions(sb);
            sb.OnStopped(OnStopped);
            sb.OnForceError(OnForceError);

            sb.Flows(
                  sb.Init
                > sb[SEQ_ID_INIT]
                > sb[SEQ_ID_CLEAR]
                > sb[SEQ_CHECK_DRY_RUN]
                > sb[SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS]
                > sb[SEQ_ID_GRAB_FIND_PROC_SEQ]
                > sb[SEQ_ID_UPDATE_UI]
                > sb[SEQ_ID_SAVE_SCREENSHOT]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_CHECK_DRY_RUN]     // Dry Run
                > sb[SEQ_ID_SET_DRY_RUN_SEQ_PARAMS]
                > sb[SEQ_ID_DRY_RUN_SEQ]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_SEQ_COMPLETE]
                > sb.Final
                );

#if SEQ_DRAW
            sb.Draw($"{GetType().Name}.pdf");
#endif

            return sb;
        }

        private SequenceActionResult Init(
           SequenceContext context,
           string id,
           SequenceActionResult param) {

            if (param.Param != null) {
                _Params = param.Param as InspSeqParams_PatternExist;
            }
            else {
                MessageBoxUtil.ShowMessageBoxError(
                    string.Format(StrTokens.MSG_E_ParamIsNull));
                return SequenceAction.Error(E1.ARGUMENT);
            }

            _SubSysInfo = _Params.FovInfo.ToSubSysInfo();
            _FovRecipe = VisionRecipeManager.GetFovRecipe(_Params.FovInfo);
            _PatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
            _AlignInfo = _Params.AlignInfo;

            return SequenceAction.Ok();
        }

        private SequenceActionResult Clear(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            var milCameraDisplay = CameraDisplayManager.GetDisplay(_Params.FovInfo, _Params.DisplayType);
            milCameraDisplay.ClearAllGraphics();
            GrabFindSeqUtil.Clear(_SubSysInfo);

            return SequenceAction.Ok();
        }

        #region Dry Run
        private string CheckDryRun(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {

            if (EquipAdapter.Instance.EquipMode.IsDryrunOrTransferMode()) {
                return SEQ_ID_SET_DRY_RUN_SEQ_PARAMS;
            }
            else {
                return SEQ_ID_SET_GRAB_FIND_PROC_SEQ_PARAMS;
            }
        }

        private SequenceActionResult SetDryRunSeqParams(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            var alignInfo = VisionRecipeManager.GetAlignInfo(_SubSysInfo.UnitId, _SubSysInfo.SubSysId, eAlignId.Align1);
            var fovInfos = new Dictionary<eFovId, FovInfo>();

            foreach (var fovInfo in VisionRecipeManager.GetFovInfos(_SubSysInfo)) {
                fovInfos.Add(fovInfo.FovId, fovInfo);
            }

            return SequenceAction.Ok(new AlignSeqParams_DryRun(alignInfo, fovInfos));
        }
        #endregion

        private SequenceActionResult SetGrabFindProcSeqParams(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_Params.FovInfo, _AlignInfo.AlignId.ToString(), eProcPatternId.ProcPattern1);

            var patternInfo = _PatternAgent.GetPatternInfo(_Params.FovInfo, procPatternInfo.PatternId);
            patternInfo.PatternName = procPatternInfo.PatternName;

            return SequenceAction.Ok(new GrabFindProcSeqParams(_Params.FovInfo, patternInfo, _Params.DisplayType));
        }

        private SequenceActionResult UpdateUI(
            SequenceContext context,
            string id,
            SequenceActionResult param) {   // Param : PatternResult

            var patternResult = param.Param as PatternResult;
            context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_EXIST_RESULT, _Params.FovInfo.GetKey()), patternResult);

            return SequenceAction.Ok();
        }

        private SequenceActionResult SaveScreenShot(
            SequenceContext context,
            string id,
            SequenceActionResult param) {

            if (EquipAdapter.Instance.EquipMode.IsNotDryrunAndTransferMode()) {
                var patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_EXIST_RESULT, _Params.FovInfo.GetKey()));
                var materialInfo = context.GetValue<MaterialInfo>(VisionContextKeys.CNTXT_KEY_MATERIAL_INFO);

                if (IsFoundStatusNG(patternResult.Status) || VisionSettingManager.VisionSetting.SaveOkSceenShotImage) {
                    _ImageManager.SaveScreenShot(_Params.FovInfo, patternResult.Status.ToString(), materialInfo, _Params.DisplayType);
                }
            }

            return SequenceAction.Ok();
        }

        private bool IsFoundStatusNG(eFoundStatus status) {
            switch (status) {
                case eFoundStatus.None:
                case eFoundStatus.NotFound:
                    return true;
                default:
                    return false;
            }
        }

        private SequenceActionResult SeqComplete(
             SequenceContext context,
             string id,
             SequenceActionResult param) {

            PatternResult patternResult = null;

            if (EquipAdapter.Instance.EquipMode.IsDryrunOrTransferMode()) {
                patternResult = new PatternResult() {
                    PatternName = "DryRun",
                    Status = eFoundStatus.None,
                    Results = new List<BaseResult>()
                };
                context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_EXIST_RESULT, _Params.FovInfo.GetKey()), patternResult);
            }
            patternResult = context.GetValue<PatternResult>(string.Format(VisionContextKeys.CNTXT_KEY_PATTERN_EXIST_RESULT, _Params.FovInfo.GetKey()));

            return SequenceAction.Ok(patternResult);
        }

        private void OnStopped(SequenceContext context) {
            LOG.I($"{context.SequenceId} - STOP Handler");
            HandleAbnormalFinish(context);
        }

        private void OnForceError(SequenceContext context, string id) {
            LOG.E($"{context.SequenceId} - FORCE ERROR Handler");
            HandleAbnormalFinish(context);
        }

        void HandleAbnormalFinish(SequenceContext context) {
        }
    }
}