LGES-OC5-PtoP-Welder/AuroraVision/VisionSequence/Aligner/AlignSeq_C1_F1_M2R.cs

using Aurora.Api;
using VisionCommon;
using VisionAligner;
using VisionCalibrator;
using VisionSequence.Pattern;
using System.Collections.Generic;
using System.Linq;
using VisionCommonUI;
using VisionCommonUI.Resources;

namespace VisionSequence.Aligner {
    /// <summary>
    /// C1_F1_M2R 얼라인 시퀀스 파라미터
    /// </summary>
    public class AlignSeqParams_C1_F1_M2R : SeqParamsBase {
        /// <summary>얼라인 키 정보</summary>
        public AlignInfo AlignInfo { get; set; }
        /// <summary>메인 화면 타입</summary>
        public eDisplayType DisplayType { get; set; }

        /// <summary>
        /// C1_F1_M2R 얼라인 시퀀스 파라미터를 얻어온다.
        /// </summary>
        /// <param name="alignInfo">얼라인 키 정보</param>
        /// <param name="displayType">메인 화면 타입</param>
        /// <param name="seqMode">시퀀스 모드</param>
        public AlignSeqParams_C1_F1_M2R(
            AlignInfo alignInfo,
            eDisplayType displayType = eDisplayType.Main_1,
            eSeqMode seqMode = eSeqMode.Auto) : base(seqMode) {

            this.AlignInfo = alignInfo;
            this.DisplayType = displayType;
        }
    }

    /// <summary>
    /// CAM 1대 / FOV 1개 / 포지션 이동 (X) / 1 Point Align / MeasurePattern to ReferencePattern
    /// </summary>
    public class AlignSeq_C1_F1_M2R : SubSeqBase {
        private readonly Logger LOG = new Logger(typeof(AlignSeq_C1_F1_M2R).Name);

        private AlignSeqParams_C1_F1_M2R _Params;
        private FovInfo _FovInfo;
        private AlignRecipe _AlignRecipe;
        private SubSysInfo _SubSysInfo;
        private PatternAgentBase _PatternAgent;
        private VisionAligner.Aligner _Aligner;
        private Calibrator _Calibrator;

        private BaseResult _MeasureResult;
        private BaseResult _ReferenceResult;

        private string _SeqName;
        private bool _IsForceOk = false;

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

        private const string SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS = "FIND_MEASURE_SEQ_PARAMS";
        private const string SEQ_ID_FIND_MEASURE_SEQ = "FIND_MEASURE_SEQ";
        private const string SEQ_ID_CHECK_MEASURE_FOUND = "CHECK_MEASURE_FOUND";
        private const string SEQ_ID_SET_MEASURE = "SET_MEASURE";

        private const string SEQ_ID_SET_FIND_REFERENCE_SEQ_PARAMS = "FIND_REFERENCE_SEQ_PARAMS";
        private const string SEQ_ID_FIND_REFERENCE_SEQ = "FIND_REFERENCE_SEQ";
        private const string SEQ_ID_CHECK_REFERENCE_FOUND = "CHECK_REFERENCE_FOUND";
        private const string SEQ_ID_SET_REFERENCE = "SET_REFERENCE";

        private const string SEQ_ID_ALIGN = "ALIGN";
        private const string SEQ_ID_SEQ_COMPLETE = "SEQ_COMPLETE";
        #endregion

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

        private void SetActions(SequenceBuilder sb) {
            SequenceBuilder grabFindProcSeqBuilder_Mea = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), "GrabFindProcSeq_Mea");
            SequenceBuilder grabFindProcSeqBuilder_Ref = SubSeqManager.CreateSubSeqBuilder(new GrabFindProcSeq(), "GrabFindProcSeq_Ref");

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

            sb.AddAction(SEQ_ID_SET_FIND_MEASURE_SEQ_PARAMS, SetFindMeasureSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_MEASURE_SEQ, grabFindProcSeqBuilder_Mea);
            sb.AddDecision(SEQ_ID_CHECK_MEASURE_FOUND, CheckFound);
            sb.AddAction(SEQ_ID_SET_MEASURE, SetMeasure);

            sb.AddAction(SEQ_ID_SET_FIND_REFERENCE_SEQ_PARAMS, SetFindReferenceSeqParams);
            sb.AddSubsequence(SEQ_ID_FIND_REFERENCE_SEQ, grabFindProcSeqBuilder_Ref);
            sb.AddDecision(SEQ_ID_CHECK_REFERENCE_FOUND, CheckFound);
            sb.AddAction(SEQ_ID_SET_REFERENCE, SetReference);

            sb.AddAction(SEQ_ID_ALIGN, Align);
            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_ID_SET_FIND_MEASURE_SEQ_PARAMS]
                > sb[SEQ_ID_FIND_MEASURE_SEQ]
                > sb[SEQ_ID_CHECK_MEASURE_FOUND]
                > sb[SEQ_ID_SET_MEASURE]
                > sb[SEQ_ID_SET_FIND_REFERENCE_SEQ_PARAMS]
                > sb[SEQ_ID_FIND_REFERENCE_SEQ]
                > sb[SEQ_ID_CHECK_REFERENCE_FOUND]
                > sb[SEQ_ID_SET_REFERENCE]
                > sb[SEQ_ID_ALIGN]
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_MEASURE_FOUND]     // Measure Mark NG
                > sb[SEQ_ID_SEQ_COMPLETE]
                );
            sb.Flows(
                  sb[SEQ_ID_CHECK_REFERENCE_FOUND]   // Reference Mark NG
                > 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 AlignSeqParams_C1_F1_M2R;
            }
            else {
                LOG.E($"Param is null.");
                return null;
            }

            _IsForceOk = false;
            _AlignRecipe = VisionRecipeManager.GetAlignRecipe(_Params.AlignInfo);
            _SubSysInfo = VisionRecipeManager.GetSubSysInfo(_Params.AlignInfo.UnitId, _Params.AlignInfo.SubSysId);
            _FovInfo = VisionRecipeManager.GetFovInfo(_SubSysInfo, eFovId.Fov1);
            _PatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
            _Aligner = AlignAgentManager.GetAlignAgent(_Params.AlignInfo);
            _Calibrator = CalibratorManager.GetCalibrator(_FovInfo);

            return SequenceAction.Ok();
        }

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

            _MeasureResult = null;
            _ReferenceResult = null;

            return SequenceAction.Ok();
        }

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

            var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfo, _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern1);
            var fovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfo);
            PatternIndex patternIndex = null;
            if (procPatternInfo.IsFovPattern) {
                _PatternAgent = FovPatternAgentManager.GetAgent(_SubSysInfo);
                patternIndex = new FovPatternIndex(_FovInfo, fovRecipe.FovName, procPatternInfo.PatternId);
            }
            else {
                _PatternAgent = CamPatternAgentManager.GetAgent(fovRecipe.CamRecipe.CamId);
                patternIndex = new CamPatternIndex(fovRecipe.CamRecipe.CamId, procPatternInfo.PatternId);
            }
            PatternInfo patternInfo = _PatternAgent.GetPatternInfo(patternIndex);
            patternInfo.PatternName = procPatternInfo.PatternName;

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

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

            var patternResult = param.Param as PatternResult;
            var baseResults = patternResult.Results.ToList();
            _MeasureResult = baseResults[0];

            return SequenceAction.Ok();
        }

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

            var procPatternInfo = VisionRecipeManager.GetProcPatternInfo(_FovInfo, _AlignRecipe.AlignId.ToString(), eProcPatternId.ProcPattern2);
            var patternInfo = _PatternAgent.GetPatternInfo(_FovInfo, procPatternInfo.PatternId);
            patternInfo.PatternName = procPatternInfo.PatternName;

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

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

            var patternResult = param.Param as PatternResult;
            var baseResults = patternResult.Results.ToList();
            _ReferenceResult = baseResults[0];

            return SequenceAction.Ok();
        }

        private string CheckFound(
            SequenceContext context,
            string id,
            ICollection<string> branches,
            SequenceActionResult param) {

            var patternResult = param.Param as PatternResult;

            if (patternResult.Status != eFoundStatus.NotFound) {
                if (patternResult.Status == eFoundStatus.ForceOK) {
                    _IsForceOk = true;
                }
                if (id == SEQ_ID_CHECK_MEASURE_FOUND) {
                    return SEQ_ID_SET_MEASURE;
                }
                else {
                    return SEQ_ID_SET_REFERENCE;
                }
            }

            context.PutValue<AlignResult>(
                string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()),
                new AlignResult() {
                    AlignName = patternResult.PatternName,
                    Status = AlignStatus.NOT_FOUND,
                    AlignAlgorithm = _AlignRecipe.ProcParams.AlignAlgorithm,
                });

            return SEQ_ID_SEQ_COMPLETE;
        }

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

            var meaAngle = _MeasureResult.Angle;
            var meaPoint = _MeasureResult.MaterialPosition;
            var refPoint = _ReferenceResult.MaterialPosition;
            var flipY = (int)_Calibrator.GetFlipY();
            var alignResult = _Aligner.Align(meaPoint, refPoint, meaAngle, flipY);

            if (alignResult == null) {
                return SequenceAction.Error();
            }
            else {
                context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()), alignResult);
            }

            return SequenceAction.Ok(alignResult);
        }

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

            AlignResult alignResult = context.GetValue<AlignResult>(string.Format(VisionContextKeys.CNTXT_KEY_ALIGN_RESULT, _Params.AlignInfo.GetKey()));
            if (alignResult == null) {
                return SequenceAction.Error();
            }
            alignResult.AlignName = _AlignRecipe.AlignName;
            if (_IsForceOk && alignResult.Status == AlignStatus.OK) {
                alignResult.Status = AlignStatus.F_OK;
            }

            context.PutValue(string.Format(VisionContextKeys.CNTXT_KEY_LAST_MEASURE_FOV_ID, _Params.AlignInfo.GetKey()), _FovInfo.FovId);

            return SequenceAction.Ok(alignResult);
        }

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

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

        void HandleAbnormalFinish(
            SequenceContext context) {
        }
    }
}