using Aurora.Api;
using Aurora.Api.DataType;
using Hermes;
using Hermes.Functional;
using Matrox.MatroxImagingLibrary;
using MilCommon;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media.Converters;
using VisionCalibrator;
using VisionCommon;

namespace MilUI {
    /// <summary>
    /// Interaction logic for CameraDisplay.xaml
    /// </summary>
    public partial class CameraDisplay : UserControl, IMilCameraDisplay, IUpdateRecipe, IDisposable {
        private const double DEFAULT_IMAGE_WIDTH = 2500.0;
        private const double DEFAULT_IMAGE_HEIGHT = 2500.0;

        private MIL_ID DisplayId = MIL.M_NULL;
        private MIL_ID ImageId = MIL.M_NULL;
        private MIL_ID GraphicContext = MIL.M_NULL;
        private MIL_ID StaticGraphicList = MIL.M_NULL;

        private MIL_ID _trainRoiLabel = MIL.M_NULL;
        private MIL_ID _trainOriginLabel = MIL.M_NULL;
        private Dictionary<eRoiIdx, MIL_ID> _findRoiLabels = new Dictionary<eRoiIdx, MIL_ID>();

        private Logger _Logger;
        private CamConfig _CamConfig;
        private CameraBase _CameraDev;
        private FovInfo _FovInfo;
        private FovRecipe _FovRecipe;
        private PatternRecipe _PatternRecipe;
        private Calibrator _Calibrator;
        private ImageSize _ImageSize;
        private eDisplayType _DisplayType;
        private IDisposable _EventDisposable;
        private Dictionary<eRoiIdx, PatternInfo> _PatternInfos = new Dictionary<eRoiIdx, PatternInfo>();

        private GCHandle ThisPtr;
        private MIL_DISP_HOOK_FUNCTION_PTR MouseLeftDownHookFuncPtr;
        private MIL_DISP_HOOK_FUNCTION_PTR MouseLeftMoveHookFuncPtr;
        private MIL_DISP_HOOK_FUNCTION_PTR MouseRightDownHookFuncPtr;
        private MIL_DISP_HOOK_FUNCTION_PTR MouseWheelHookFuncPtr;
        private MIL_GRA_HOOK_FUNCTION_PTR GraphicSelectionModifiedHookFuncPtr;
        private GridGuideLine _gridGuideLine;
        private MilGraphics _patternResultGraphics;
        private MilGraphics _patternTrackingGraphics;
        private MilGraphics _trainGraphics;
        private MilGraphics _findGraphics;
        private Dictionary<eRoiIdx, MilGraphics> _findLabelNumGraphicsDic = new Dictionary<eRoiIdx, MilGraphics>();
        private DisplayMode _displayMode;
        private eDisplayMode _curDisplayMode = eDisplayMode.None;

        #region TrainRoi & FindRoi Changed Event
        private GCHandle _TrainRoiChangedDataHandle;
        private GCHandle _TrainOriginChangedDataHandle;
        private Dictionary<eRoiIdx, GCHandle> _FindRoiChangedDataHandles = new Dictionary<eRoiIdx, GCHandle>();
        private MIL_GRA_HOOK_FUNCTION_PTR _OnTrainRoiChangedFuncPtr;
        private MIL_GRA_HOOK_FUNCTION_PTR _OnTrainOriginChangedFuncPtr;
        private Dictionary<eRoiIdx, MIL_GRA_HOOK_FUNCTION_PTR> _OnFindRoiChangedFuncPtrs = new Dictionary<eRoiIdx, MIL_GRA_HOOK_FUNCTION_PTR>();
        #endregion

        private bool _Initialized = false;

        public CameraDisplay() {
            InitializeComponent();
        }

        public void SetPatternInfo(PatternInfo patternInfo, eRoiIdx roiIdx = eRoiIdx.Roi0) {
            _PatternInfos[roiIdx] = patternInfo;
        }

        public int Init(CameraBase cameraDev, eDisplayType displayType, CamConfig camConfig, FovInfo fovInfo, FovRecipe fovRecipe) {
            if (_Initialized) {
                return E1.OK;
            }

            _Logger = new Logger(string.Format("CameraDisplay[{0}]", fovRecipe.FovName));
            _CameraDev = cameraDev;
            _CamConfig = camConfig;
            _DisplayType = displayType;
            _FovInfo = fovInfo;
            _FovRecipe = fovRecipe;
            _PatternRecipe = VisionRecipeManager.GetPatternRecipe(_FovInfo.ToSubSysInfo(), _FovInfo.FovId);
            _Calibrator = CalibratorManager.GetCalibrator(_FovInfo);

            if (_CameraDev != null && _CamConfig != null && MilEnvironment.Instance.HasValidLicense()) {
                // Config와 MilSystem은 Camera가 Activate된 이후에 사용할 수 있다.
                // 그러나 시점상 Display관련 UI를 생성할 때는 위 객체들이 null이기 때문에 조치 필요..
                // Camera Activate보다 View가 우선 실행되어 CamConfig를 직접 받는것으로 수정.. 문제 해결 후 원복
                //_ImageSize = _CameraDev.GetImageSize();
                _ImageSize = _CamConfig.ImageSize;
                ImageId = MilEnvironment.GetCompatibleImageBuffer(
                    _ImageSize, _CamConfig.CamConnConfig.BoardType, _CamConfig.CamConnConfig.BoardSlotPos);
                DisplayId = MilEnvironment.Instance.CreateDisplay(winFormPanel.Handle, ImageId);

                MIL_ID sysId = MilEnvironment.Instance.GetSystem(_CamConfig.CamConnConfig.BoardType, _CamConfig.CamConnConfig.BoardSlotPos);
                AllocGraphics(sysId);
                SetObservable();
                CreateGraphics();
                DrawGuideLines();
                SetHookFunc();

                _Initialized = true;
            }
            else {
                _Logger.FuncE("Failed to initialize camera display view.");
            }

            return E1.OK;
        }

        private void AllocGraphics(MIL_ID sysId) {
            MIL.MgraAlloc(sysId, ref GraphicContext);
            MIL.MgraAllocList(sysId, MIL.M_DEFAULT, ref StaticGraphicList);
            MIL.MdispControl(DisplayId, MIL.M_MOUSE_USE, MIL.M_ENABLE);
            MIL.MdispControl(DisplayId, MIL.M_SCALE_DISPLAY, MIL.M_ENABLE);
            MIL.MdispControl(DisplayId, MIL.M_CENTER_DISPLAY, MIL.M_ENABLE);
            MIL.MdispControl(DisplayId, MIL.M_MOUSE_CURSOR_CHANGE, MIL.M_DISABLE);
            MIL.MdispControl(DisplayId, MIL.M_GRAPHIC_LIST_INTERACTIVE, MIL.M_ENABLE);
            MIL.MdispControl(DisplayId, MIL.M_ASSOCIATED_GRAPHIC_LIST_ID, StaticGraphicList);
        }

        private void SetObservable() {
            _EventDisposable = VisionEnv.AuroraEnv.EventObservable.AsObservable(DiplayModeEvent.On)
                .Where(x => x.From == _FovRecipe.FovName)
                .Where(x => ((DisplayModeParam)x.Param).DisplayType == _DisplayType)
                .Subscribe(msg => OnDisplayMode(msg));

            _EventDisposable = VisionEnv.AuroraEnv.EventObservable.AsObservable(DiplayModeEvent.Off)
                .Where(x => x.From == _FovRecipe.FovName)
                .Where(x => ((DisplayModeParam)x.Param).DisplayType == _DisplayType)
                .Subscribe(msg => OffDisplayMode(msg));
        }

        public void OnDisplayMode(EventMessage msg) {
            _Logger.FuncI();

            if (_curDisplayMode != eDisplayMode.None) {
                RulerModeOff(_curDisplayMode);
            }
            _curDisplayMode = eDisplayMode.None;
            _displayMode = (msg.Param as DisplayModeParam).DisplayMode;
        }

        public void OffDisplayMode(EventMessage msg) {
            _Logger.FuncI();

            _curDisplayMode = eDisplayMode.None;
            _displayMode?.Clear();
            _displayMode = null;
        }

        private void CreateGraphics() {
            _patternResultGraphics = new MilGraphics(DisplayId, StaticGraphicList);
            _patternTrackingGraphics = new MilGraphics(DisplayId, StaticGraphicList);
            _trainGraphics = new MilGraphics(DisplayId, StaticGraphicList);
            _findGraphics = new MilGraphics(DisplayId, StaticGraphicList);
            _gridGuideLine = new GridGuideLine(DisplayId, GraphicContext, StaticGraphicList, _FovInfo);
        }

        public void DrawGuideLines() {
            var calFovRecipe = VisionRecipeManager.GetCalFovRecipe(_FovInfo);
            var centerPos = new ImagePoint(_ImageSize.Width / 2, _ImageSize.Height / 2);
            var color = MIL.M_RGB888(255, 165, 0);  // Orange

            _gridGuideLine.DrawGuideLines(_ImageSize, centerPos, 1, color, calFovRecipe.ErrRotationX);
            //_gridGuideLine.DrawRefLine(_ImageSize, calFovRecipe.ErrRotationX);
            //_gridGuideLine.DrawCoordDirection(_ImageSize);
        }

        private void SetHookFunc() {
            if (!ThisPtr.IsAllocated) {
                ThisPtr = GCHandle.Alloc(this);
                MouseLeftDownHookFuncPtr = new MIL_DISP_HOOK_FUNCTION_PTR(MouseLeftDownHookFunc);
                MouseLeftMoveHookFuncPtr = new MIL_DISP_HOOK_FUNCTION_PTR(MouseMoveHookFunc);
                MouseRightDownHookFuncPtr = new MIL_DISP_HOOK_FUNCTION_PTR(MouseRightDownHookFunc);
                MouseWheelHookFuncPtr = new MIL_DISP_HOOK_FUNCTION_PTR(MouseWheelHookFunc);
                GraphicSelectionModifiedHookFuncPtr = new MIL_GRA_HOOK_FUNCTION_PTR(GraphicSelectionModifiedHookFunc);

                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_LEFT_BUTTON_DOWN, MouseLeftDownHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_MOVE, MouseLeftMoveHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_RIGHT_BUTTON_DOWN, MouseRightDownHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_WHEEL, MouseWheelHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MgraHookFunction(StaticGraphicList, MIL.M_GRAPHIC_SELECTION_MODIFIED, GraphicSelectionModifiedHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
            }
        }

        public MIL_INT MouseLeftDownHookFunc(MIL_INT HookType, MIL_ID EventID, IntPtr UserDataPtr) {
            if (_displayMode != null) {
                _displayMode.MouseLeftDown(EventID);
            }

            return 0;
        }

        public MIL_INT MouseMoveHookFunc(MIL_INT HookType, MIL_ID EventID, IntPtr UserDataPtr) {
            if (_displayMode != null) {
                _displayMode.MouseMove(EventID);
            }

            UpdateCurrentPointToStatusBar(EventID);

            return 0;
        }

        public MIL_INT MouseRightDownHookFunc(MIL_INT HookType, MIL_ID EventID, IntPtr UserDataPtr) {
            if (_displayMode != null) {
                _displayMode.MouseRightDown(EventID);
            }

            return 0;
        }

        public MIL_INT MouseWheelHookFunc(MIL_INT HookType, MIL_ID EventID, IntPtr UserDataPtr) {
            UpdateCurrentZoomToStatusBar();
            UpdateCurrentPointToStatusBar(EventID);

            return 0;
        }

        public MIL_INT GraphicSelectionModifiedHookFunc(MIL_INT HookType, MIL_ID EventID, IntPtr UserDataPtr) {
            if (_displayMode != null) {
                _displayMode.GraphicSelectionModified(EventID);
            }

            return 0;
        }

        private void UserControl_SizeChanged(object sender, SizeChangedEventArgs e) {
            if (IsLoaded && (e.WidthChanged || e.HeightChanged)) {
                ImageSize imageSize = MilEnvironment.GetImageSize(GetImage());
                FitImage(imageSize);
            }
        }

        private void UserControl_Loaded(object sender, RoutedEventArgs e) {
            var imageId = GetImage();
            if (imageId != MIL.M_NULL) {
                ImageSize imageSize = MilEnvironment.GetImageSize(GetImage());
                FitImage(imageSize);
            }
        }

        public void ClearImage() {
            MilEnvironment.ClearImage(this.ImageId);
        }

        public int FitImage(ImageSize imageSize) {
            try {
                if (DisplayId != MIL.M_NULL &&
                    MilEnvironment.Instance.HasValidLicense()) {

                    if (MilEnvironment.IsImageSizeNull(imageSize)) {
                        imageSize = _CameraDev.GetImageSize();
                    }

                    double zoomX = (double)winFormPanel.Width / imageSize.Width;
                    double zoomY = (double)winFormPanel.Height / imageSize.Height;
                    // 이미지 원본의 비율을 유지하면서 영상의 모든 영역이 디스플레이에 출력되어야 한다.
                    double minZoom = Math.Min(zoomX, zoomY);
                    SetAbsImageZoom(minZoom);
                }
                return E1.OK;
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }

            return E1.GENERIC;
        }

        public int SetImage(object image) {
            var milImage = (MIL_ID)image;

            if (this.ImageId != milImage) {
                UpdateImageBufferSize(milImage);
                MIL.MbufCopy(milImage, this.ImageId);
            }

            return E1.OK;
        }

        public bool IsSetImage() {
            if (ImageId != MIL.M_NULL) {
                return true;
            }
            else {
                return false;
            }
        }

        public void UpdateImageBufferSize(MIL_ID imageId) {
            if (!MilEnvironment.Instance.HasValidLicense()) {
                return;
            }

            if (IsTimeToUpdate(imageId)) {
                MilEnvironment.FreeImage(ImageId);

                _ImageSize = MilEnvironment.GetImageSize(imageId);
                ImageId = MilEnvironment.GetCompatibleImageBuffer(
                    _ImageSize, _CamConfig.CamConnConfig.BoardType, _CamConfig.CamConnConfig.BoardSlotPos);
                Application.Current.Dispatcher.Invoke(
                    new Action(() => {
                        MilEnvironment.Instance.SelectDisplay(winFormPanel.Handle, ImageId, DisplayId);
                    }));

                FitImage(_ImageSize);
                _gridGuideLine?.Update(_ImageSize);
            }
        }

        private bool IsTimeToUpdate(MIL_ID imageId) {
            if (ImageId == MIL.M_NULL) {
                return true;
            }

            var displaySize = MilEnvironment.GetImageSize(ImageId);
            var imageSize = MilEnvironment.GetImageSize(imageId);

            if (displaySize.Width != imageSize.Width ||
                displaySize.Height != imageSize.Height ||
                displaySize.Channel != imageSize.Channel ||
                displaySize.BitDepth != imageSize.BitDepth) {
                return true;
            }

            return false;
        }

        public object GetImageObject() {
            return (object)ImageId;
        }

        public MIL_ID GetImage() {
            return ImageId;
        }

        public MIL_ID GetMilDisplayId() {
            return DisplayId;
        }

        public MIL_ID GetGraphicContextId() {
            return GraphicContext;
        }

        public MIL_ID GetGraphicListId() {
            return StaticGraphicList;
        }

        public CamRecipe GetCamRecipe() {
            return _FovRecipe.CamRecipe;
        }

        public FovInfo GetDisplayFovInfo() {
            return _FovInfo;
        }

        public eDisplayType GetDisplayType() {
            return _DisplayType;
        }

        public int RulerModeOn(eDisplayMode displayMode) {
            if (_curDisplayMode != eDisplayMode.None) {
                RulerModeOff(_curDisplayMode);
            }
            _curDisplayMode = displayMode;

            ImageSize imageSize;
            if (ImageId != MIL.M_NULL) {
                imageSize = MilEnvironment.GetImageSize(ImageId);
            }
            else {
                imageSize = new ImageSize() {
                    Width = (int)DEFAULT_IMAGE_WIDTH,
                    Height = (int)DEFAULT_IMAGE_HEIGHT
                };
            }

            switch (displayMode) {
                case eDisplayMode.DistanceAngle:
                    _displayMode = new RulerMode(
                        DisplayId, GraphicContext, StaticGraphicList, imageSize,
                        _FovRecipe.CalFovRecipe.PixelSize.Clone() as StaticPoint);
                    break;
                case eDisplayMode.Position:
                    _displayMode = new PositionMode(
                        _FovInfo,
                        DisplayId, GraphicContext, StaticGraphicList, imageSize,
                        _FovRecipe.CalFovRecipe.PixelSize.Clone() as StaticPoint);
                    break;
                case eDisplayMode.Circle:
                    _displayMode = new CircleMode(
                        DisplayId, GraphicContext, StaticGraphicList, imageSize,
                        _FovRecipe.CalFovRecipe.PixelSize.Clone() as StaticPoint);
                    break;
                case eDisplayMode.MovePosition:
                    _displayMode = new MovePositionMode(_FovInfo, imageSize);
                    break;
                default:
                    break;
            }

            return E1.OK;
        }

        public int RulerModeOff(eDisplayMode displayMode) {
            _displayMode?.Clear();
            _displayMode = null;
            _curDisplayMode = eDisplayMode.None;

            return E1.OK;
        }

        public void SetWideGridGuideLine() {
            if (ImageId != MIL.M_NULL) {
                _gridGuideLine.WideOn(MilEnvironment.GetImageSize(ImageId));
            }
        }

        public void SetNarrowGridGuideLine() {
            if (ImageId != MIL.M_NULL) {
                _gridGuideLine.NarrowOn(MilEnvironment.GetImageSize(ImageId));
            }
        }

        public void SetWideGridGuideLine_ErrRotation() {
            if (ImageId != MIL.M_NULL) {
                _gridGuideLine.WideOn(MilEnvironment.GetImageSize(ImageId), true);
            }
        }

        public void SetNarrowGridGuideLine_ErrRotation() {
            if (ImageId != MIL.M_NULL) {
                _gridGuideLine.NarrowOn(MilEnvironment.GetImageSize(ImageId), true);
            }
        }

        public void ClearGridGuidLine() {
            _gridGuideLine.Clear();
        }

        public int SetPatternTracking(Cross newCross) {
            if (_PatternRecipe.TrackingParam.Enabled) {
                PatternTrackingManager.AddCross(_FovInfo, newCross);
            }
            return E1.OK;
        }

        public int DrawPatternTrackings(List<Cross> newCrosses) {
            ClearPatternTrackingGraphics();

            if (_PatternRecipe.TrackingParam.Enabled) {
                Application.Current.Dispatcher.BeginInvoke(
                    new System.Action(() => {
                        var color = ColorConverter.ConvertColor(eColor.Orange);
                        var crossTrackings = PatternTrackingManager.GetCrosses(_FovInfo, _PatternRecipe.TrackingParam.Count + 1);
                        RemoveDuplicateCross(newCrosses, crossTrackings);
                        DisplayDrawer.AddCrosses(DisplayId, GraphicContext, StaticGraphicList, color, _patternTrackingGraphics, crossTrackings);
                    }));
            }
            return E1.OK;
        }

        private void RemoveDuplicateCross(List<Cross> newCrosses, List<Cross> crossTrackings) {
            foreach (Cross newCross in newCrosses) {
                for (int i = 0; i < crossTrackings.Count; i++) {
                    if (crossTrackings[i].Equals(newCross)) {
                        crossTrackings.Remove(newCross);
                    }
                }
            }
        }

        /// <summary>
        /// 레퍼런스 위치에 십자가 그리기
        /// </summary>
        /// <param name="length">십자가 길이</param>
        /// <param name="color">십자가 색상</param>
        public void DrawRefCross(int length = 10, eColor color = eColor.Yellow) {
            var refPointRecipe = VisionRecipeManager.GetRefPointRecipe(_FovInfo);
            if (refPointRecipe == null) {
                _Logger.E($"refPointRecipe is null");
                return;
            }

            ImagePoint refPos = GetRefPos(_ImageSize);
            AddCross(new Cross(refPos, length), color);
        }

        private ImagePoint GetRefPos(ImageSize imageSize) {
            var calibrator = CalibratorManager.GetCalibrator(_FovInfo);
            var staticRefPoint = VisionRecipeManager.GetRefPoint(_FovInfo);
            var imageRefPoint = calibrator.TransformToImagePoint(staticRefPoint, imageSize);

            return new ImagePoint(imageRefPoint.X, imageRefPoint.Y);
        }

        public void DrawStrReadResult(MIL_ID resultContextId, ROI roi) {
            DisplayDrawer.DrawStrReadResult(DisplayId, resultContextId, GraphicContext, StaticGraphicList, _patternResultGraphics, roi);
        }

        public void DrawOcrReadResult(MIL_ID resultContextId, ROI roi) {
            DisplayDrawer.DrawOcrReadResult(DisplayId, resultContextId, GraphicContext, StaticGraphicList, _patternResultGraphics, roi);
        }

        public int AddPatternEdge(MIL_ID resultContextId, ROI roi) {
            DisplayDrawer.AddPatternEdge(DisplayId, resultContextId, GraphicContext, StaticGraphicList, _patternResultGraphics, roi);
            return E1.OK;
        }

        public int AddCross(Cross cross, eColor color) {
            return AddCross(cross, ColorConverter.ConvertColor(color));
        }

        public int AddCross(Cross cross, MIL_INT color) {
            DisplayDrawer.AddCross(DisplayId, GraphicContext, StaticGraphicList, color, _patternResultGraphics, cross);
            return E1.OK;
        }

        public int AddCrosses(List<Cross> crosses, MIL_INT color) {
            DisplayDrawer.AddCrosses(DisplayId, GraphicContext, StaticGraphicList, color, _patternResultGraphics, crosses);
            return E1.OK;
        }

        public int AddLine(eColor color, ImagePoint p1, ImagePoint p2) {
            var line = new Line<ImagePoint>(p1, p2);
            return AddLine(ColorConverter.ConvertColor(color), line, false);
        }

        public int AddLine(MIL_INT color, Line<ImagePoint> line, bool isEditable) {
            DisplayDrawer.AddLine(GraphicContext, StaticGraphicList, color, _patternResultGraphics, line, isEditable);
            return E1.OK;
        }

        public int AddLines(MIL_INT color, List<Line<ImagePoint>> lines) {
            DisplayDrawer.AddLines(DisplayId, GraphicContext, StaticGraphicList, color, _patternResultGraphics, lines);
            return E1.OK;
        }

        public int AddVectors(MIL_INT color, List<Line<ImagePoint>> lines, bool drawTail) {
            DisplayDrawer.AddVectors(
                DisplayId, GraphicContext, StaticGraphicList, color, _patternResultGraphics, lines, drawTail);
            return E1.OK;
        }

        public void AddRoi(ROI roi, eColor color, bool isRotatable = false) {
            if (ROI.IsNullOrEmpty(roi)) {
                DisplayDrawer.AddRoi(
                    GraphicContext, StaticGraphicList, ColorConverter.ConvertColor(color), _patternResultGraphics, roi, false);
            }
        }

        public int AddTrainRoi(ImagePoint imageCenter, bool isRotatable = false) {
            var length = 200;
            return AddTrainRoi(new ROI(imageCenter, length, length, new Angle()), isRotatable);
        }

        public int AddTrainRoi(ROI trainRoi, bool isRotatable = false) {
            if (HasTrainRoi()) {
                _trainGraphics.Remove(_trainRoiLabel);
            }

            MIL.MgraColor(GraphicContext, MIL.M_COLOR_BLUE);
            MIL.MgraRectAngle(
                GraphicContext,
                StaticGraphicList,
                trainRoi.Center.X,
                trainRoi.Center.Y,
                trainRoi.Width,
                trainRoi.Height,
                trainRoi.Angle.Degree,
                MIL.M_CENTER_AND_DIMENSION);

            MIL.MgraInquireList(StaticGraphicList, MIL.M_LIST, MIL.M_DEFAULT, MIL.M_LAST_LABEL, ref _trainRoiLabel);

            if (isRotatable) {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_ROTATABLE, MIL.M_ENABLE);
            }
            else {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_ROTATABLE, MIL.M_DISABLE);
            }

            SetTrainRoiChangedEvent();
            _trainGraphics.Add();

            return E1.OK;
        }

        public ROI GetTrainRoi() {
            if (_trainRoiLabel == MIL.M_NULL) {
                return new ROI(0, 0, 0, 0);
            }
            double centerX = 0;
            double centerY = 0;
            double width = 0;
            double height = 0;
            double angle = 0;

            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_CENTER_X, ref centerX);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_CENTER_Y, ref centerY);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_RECTANGLE_WIDTH, ref width);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_RECTANGLE_HEIGHT, ref height);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_ANGLE, ref angle);

            var convParam = ConvertDoubleToInt(centerX, centerY, width, height);
            return new ROI(
                convParam.centerX, convParam.centerY, convParam.width, convParam.height, Angle.CreateWithDegree(angle));
        }

        private (double centerX, double centerY, int width, int height) ConvertDoubleToInt(double centerX, double centerY, double width, double height) {
            int left = (int)Math.Round(centerX - width / 2.0);
            int top = (int)Math.Round(centerY - height / 2.0);
            int right = (int)Math.Round(centerX + width / 2.0);
            int bottom = (int)Math.Round(centerY + height / 2.0);

            int intWidth = right - left;
            int intHeight = bottom - top;

            double dbCenterX = left + intWidth * 0.5;
            double dbCenterY = top + intHeight * 0.5;
            return (dbCenterX, dbCenterY, intWidth, intHeight);
        }

        public void UpdateAngleOfTrainRoi(double roiAngle) {
            if (HasTrainRoi()) {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainRoiLabel), MIL.M_DEFAULT, MIL.M_ANGLE, roiAngle);
            }
        }

        public bool HasTrainRoi() {
            return _trainGraphics != null && _trainGraphics.HasGraphicLabel(_trainRoiLabel);
        }

        public int AddTrainOrigin(Cross imageCenter) {
            if (_trainOriginLabel != MIL.M_NULL) {
                return E1.GENERIC;
            }

            double radius = imageCenter.Length > 0 ? imageCenter.Length : 25;

            MIL.MgraArc(GraphicContext, StaticGraphicList, imageCenter.Origin.X, imageCenter.Origin.Y, radius, radius, 0, 360);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_LIST, MIL.M_DEFAULT, MIL.M_LAST_LABEL, ref _trainOriginLabel);
            MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RESIZABLE, MIL.M_ENABLE);
            MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_CONSTRAIN_ASPECT_RATIO, 1.0);
            MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_SPECIFIC_FEATURES_EDITABLE, MIL.M_DISABLE);

            SetTrainOriginChangedEvent();
            _trainGraphics.Add();

            return E1.OK;
        }

        public Cross GetTrainOrigin() {
            if (_trainOriginLabel == MIL.M_NULL) {
                return new Cross(new ImagePoint(0, 0));
            }

            double x = 0;
            double y = 0;
            double radius = 0;
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_POSITION_X, ref x);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_POSITION_Y, ref y);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_X, ref radius);

            return new Cross(new ImagePoint(x, y), radius);
        }

        public void UpdateRadiusOfTrainOrigin(double radius) {
            if (HasTrainOrigin()) {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_X, radius);
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_Y, radius);
            }
        }

        public bool HasTrainOrigin() {
            return _trainGraphics != null && _trainGraphics.HasGraphicLabel(_trainOriginLabel);
        }

        public int AddDefaultFindRoi(ImageSize imageSize, bool isRotatable = false) {
            if (!_findRoiLabels.ContainsKey(eRoiIdx.Roi0)) {
                _findRoiLabels.Add(eRoiIdx.Roi0, MIL.M_NULL);
            }

            if (_findRoiLabels[eRoiIdx.Roi0] != MIL.M_NULL) {
                return E1.GENERIC;
            }

            var roi = RoiUtil.GetDefaultFindRoi(imageSize);
            return AddFindRoi(roi, isRotatable);
        }

        public int AddFindRoi(ROI findRoi, bool isRotatable = false) {
            if (findRoi.RoiIdx == eRoiIdx.Roi0) {
                ClearFindRoi();     // Multi Pattern의 경우 Clear가 필요 없음.
            }

            MIL.MgraColor(GraphicContext, ColorConverter.ConvertColor(findRoi.RoiColor));
            MIL.MgraRectAngle(
                GraphicContext,
                StaticGraphicList,
                findRoi.CenterX,
                findRoi.CenterY,
                findRoi.Width,
                findRoi.Height,
                findRoi.Angle.Degree,
                MIL.M_CENTER_AND_DIMENSION);

            var findRoiLabel = MIL.M_NULL;
            MIL.MgraInquireList(StaticGraphicList, MIL.M_LIST, MIL.M_DEFAULT, MIL.M_LAST_LABEL, ref findRoiLabel);
            _findRoiLabels[findRoi.RoiIdx] = findRoiLabel;

            if (isRotatable) {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[findRoi.RoiIdx]), MIL.M_DEFAULT, MIL.M_ROTATABLE, MIL.M_ENABLE);
            }
            else {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[findRoi.RoiIdx]), MIL.M_DEFAULT, MIL.M_ROTATABLE, MIL.M_DISABLE);
            }

            _findGraphics.Add();
            AddFindRoiLabelNum(findRoi, findRoi.RoiIdx);
            SetFindRoiChangedEvent(findRoi.RoiIdx);

            return E1.OK;
        }

        private void AddFindRoiLabelNum(ROI findRoi, eRoiIdx roiIdx) {
            if (roiIdx != eRoiIdx.Roi0) {
                if (!_findLabelNumGraphicsDic.ContainsKey(roiIdx)) {
                    _findLabelNumGraphicsDic[roiIdx] = new MilGraphics(DisplayId, StaticGraphicList);
                }
                else {
                    _findLabelNumGraphicsDic[roiIdx].Clear();
                }

                var msgs = new List<string>() { ((int)roiIdx).ToString() };
                var imageSize = MilEnvironment.GetImageSize(ImageId);

                DisplayDrawer.AddTextList(DisplayId, GraphicContext, StaticGraphicList, ColorConverter.ConvertColor(eColor.Orange),
                    _findLabelNumGraphicsDic[roiIdx], imageSize, findRoi.RightBottom, msgs);
            }
        }

        public ROI GetFindRoi(eRoiIdx roiIdx = eRoiIdx.Roi0) {
            if (!HasFindRoi(roiIdx)) {
                return new ROI() { RoiIdx = roiIdx };
            }

            double centerX = 0;
            double centerY = 0;
            double width = 0;
            double height = 0;
            double angle = 0;

            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_CENTER_X, ref centerX);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_CENTER_Y, ref centerY);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_RECTANGLE_WIDTH, ref width);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_RECTANGLE_HEIGHT, ref height);
            MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_ANGLE, ref angle);

            var convParam = ConvertDoubleToInt(centerX, centerY, width, height);
            return new ROI(
                convParam.centerX, convParam.centerY, convParam.width, convParam.height, Angle.CreateWithDegree(angle), roiIdx);
        }

        public void UpdateAngleOfFindRoi(double roiAngle, eRoiIdx roiIdx = eRoiIdx.Roi0) {
            if (HasFindRoi(roiIdx)) {
                MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_findRoiLabels[roiIdx]), MIL.M_DEFAULT, MIL.M_ANGLE, roiAngle);
            }
        }

        public bool HasFindRoi(eRoiIdx roiIdx = eRoiIdx.Roi0) {
            if (_findRoiLabels.ContainsKey(roiIdx)) {
                return _findGraphics != null && _findGraphics.HasGraphicLabel(_findRoiLabels[roiIdx]);
            }
            return false;
        }

        public void ClearFindRoi(eRoiIdx roiIdx = eRoiIdx.Roi0) {
            if (HasFindRoi(roiIdx)) {
                _findGraphics.Remove(_findRoiLabels[roiIdx]);
                _findRoiLabels.Remove(roiIdx);
            }
        }

        public int AddPatternResultFindRoi(MIL_INT color, List<ROI> findRois) {
            foreach (var roi in findRois) {
                AddPatternResultFindRoi(color, roi);
            }
            return E1.OK;
        }

        public int AddPatternResultFindRoi(MIL_INT color, ROI findRoi) {
            if (ROI.IsNullOrEmpty(findRoi)) {
                var imageSize = MilEnvironment.GetImageSize(GetImage());
                var defaultFindRoi = RoiUtil.GetDefaultFindRoi(imageSize);
                DisplayDrawer.AddRoi(
                    GraphicContext, StaticGraphicList, color, _patternResultGraphics, defaultFindRoi, false);
            }
            else {
                DisplayDrawer.AddRoi(
                    GraphicContext, StaticGraphicList, color, _patternResultGraphics, findRoi, false);
            }

            return E1.OK;
        }

        public int AddPatternResultDots(MIL_INT color, List<ImagePoint> dots) {
            DisplayDrawer.AddPatternResultDots(
                DisplayId, GraphicContext, StaticGraphicList,
                color, _patternResultGraphics, dots);

            return E1.OK;
        }

        public int AddTextList(eColor color, ImagePoint p, List<string> msgs) {
            return AddTextList(ColorConverter.ConvertColor(color), p, msgs);
        }

        public int AddTextList(object color, ImagePoint p, List<string> msgs) {
            var imageSize = MilEnvironment.GetImageSize(ImageId);
            DisplayDrawer.AddTextList(
                DisplayId, GraphicContext, StaticGraphicList, (MIL_INT)color, _patternResultGraphics, imageSize, p, msgs);

            return E1.OK;
        }

        public int AddTextList(object color, ImagePoint p, List<string> msgs, int lineInterval) {
            var imageSize = MilEnvironment.GetImageSize(ImageId);
            DisplayDrawer.AddTextList(
                DisplayId, GraphicContext, StaticGraphicList, (MIL_INT)color, _patternResultGraphics, imageSize, p, msgs, lineInterval);

            return E1.OK;
        }

        public int AddColorTextList(ImagePoint p, List<ColorText> colorTextList) {
            var imageSize = MilEnvironment.GetImageSize(ImageId);
            DisplayDrawer.AddColorTextList(
                DisplayId, GraphicContext, StaticGraphicList, _patternResultGraphics, imageSize, p, colorTextList);

            return E1.OK;
        }

        public int AddColorTextList(ImagePoint p, List<ColorText> colorTextList, int lineInterval) {
            var imageSize = MilEnvironment.GetImageSize(ImageId);
            DisplayDrawer.AddColorTextList(
                DisplayId, GraphicContext, StaticGraphicList, _patternResultGraphics, imageSize, p, colorTextList, lineInterval);

            return E1.OK;
        }

        public int ClearAllGraphics() {
            ClearMeasureGraphics();
            ClearTrainGraphics();
            ClearFindGraphics();

            if (MilEnvironment.Instance.HasValidLicense()) {
                MIL.MgraClear(GraphicContext, StaticGraphicList);
            }

            return E1.OK;
        }

        public int ClearMeasureGraphics(eGraphicToClear graphicToClear = eGraphicToClear.ALL) {
            // Clear graphics of DisplayMode and PatternResult
            _displayMode?.Clear();
            _patternResultGraphics?.Clear();

            return E1.OK;
        }

        public int ClearTrainGraphics(eGraphicToClear graphicToClear = eGraphicToClear.ALL) {
            RemoveTrainRoiChangedEvent();
            RemoveTrainOriginChangedEvent();
            _trainGraphics?.Clear();
            _trainRoiLabel = MIL.M_NULL;
            _trainOriginLabel = MIL.M_NULL;

            return E1.OK;
        }

        public int ClearFindGraphics(eGraphicToClear graphicToClear = eGraphicToClear.ALL) {
            _findGraphics?.Clear();

            for (int i = 0; i < _findRoiLabels.Count; i++) {
                if (HasFindRoi((eRoiIdx)i)) {
                    _findRoiLabels[(eRoiIdx)i] = MIL.M_NULL;
                }
            }

            return E1.OK;
        }

        public int ClearPatternTrackingGraphics(eGraphicToClear graphicToClear = eGraphicToClear.ALL) {
            _patternTrackingGraphics?.Clear();

            return E1.OK;
        }

        public void ClearFindLabelNumGraphicsAll() {
            foreach (var itemPair in _findLabelNumGraphicsDic) {
                MilGraphics milGraphics = itemPair.Value;
                milGraphics?.Clear();
            }
            _findLabelNumGraphicsDic.Clear();
        }

        public void ClearFindLabelNumGraphics(eRoiIdx roiIdx) {
            if (_findLabelNumGraphicsDic.ContainsKey(roiIdx)) {
                _findLabelNumGraphicsDic[roiIdx]?.Clear();
            }
        }

        // 메인 화면에 _FovInfo에 해당하는 디스플레이만 보이기
        public void SetVisibility() {
            var fovUiPos = VisionRecipeManager.GetFovUiPos(_FovRecipe, _DisplayType);
            CameraViewManager.Instance.SetVisibilities(_FovInfo, fovUiPos, _DisplayType);
        }


        private void winFormPanel_MouseDoubleClick(object sender, System.Windows.Forms.MouseEventArgs e) {
            ImageSize imageSize = MilEnvironment.GetImageSize(GetImage());
            FitImage(imageSize);
        }

        private void UserControl_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
            bool isVisible = (bool)e.NewValue;
            if (isVisible == true) {
                RefreshVisionRecipes();
            }
        }

        public void RefreshVisionRecipes() {
            if (_FovInfo != null) {
                _FovRecipe = VisionRecipeManager.GetFovRecipe(_FovInfo);
                _PatternRecipe = VisionRecipeManager.GetPatternRecipe(_FovInfo.ToSubSysInfo(), _FovInfo.FovId);
            }
        }

        public void UpdateRecipeFromFile() {
            throw new NotImplementedException();
        }

        public void UpdateRecipeFromUI() {
            throw new NotImplementedException();
        }

        private void UpdateCurrentZoomToStatusBar() {
            double imageZoom = GetImageZoom();
            double displayZoom = GetDisplayZoom();
            curZoom.Text = $"Zoom (X{imageZoom / displayZoom:F2}, {imageZoom:F2})";
        }

        public void SetAbsImageZoom(double zoom) {
            if (zoom > 0) {
                MIL.MdispZoom(DisplayId, zoom, zoom);
                Application.Current.Dispatcher.BeginInvoke(
                    new Action(() => {
                        UpdateCurrentZoomToStatusBar();
                    }
                ));
            }
        }

        public void SetRelativeImageZoom(double relZoom) {
            SetAbsImageZoom(GetImageZoom() + relZoom);
        }

        public double GetImageZoom() {
            double imageZoomX = 0;
            double imageZoomY = 0;

            MIL.MdispInquire(DisplayId, MIL.M_ZOOM_FACTOR_X, ref imageZoomX);
            MIL.MdispInquire(DisplayId, MIL.M_ZOOM_FACTOR_Y, ref imageZoomY);

            return Math.Round(Math.Min(imageZoomX, imageZoomY), 2);
        }

        public double GetDisplayZoom() {
            MIL_INT sizeX = 0;
            MIL_INT sizeY = 0;
            MIL.MdispInquire(DisplayId, MIL.M_SIZE_X, ref sizeX);
            MIL.MdispInquire(DisplayId, MIL.M_SIZE_Y, ref sizeY);

            double displayZoomX = (double)sizeX / _ImageSize.Width;
            double displayZoomY = (double)sizeY / _ImageSize.Height;

            return Math.Round(Math.Min(displayZoomX, displayZoomY), 2);
        }

        private void UpdateCurrentPointToStatusBar(MIL_ID EventID) {
            double x = 0;
            double y = 0;
            MIL.MdispGetHookInfo(EventID, MIL.M_MOUSE_POSITION_BUFFER_X, ref x);
            MIL.MdispGetHookInfo(EventID, MIL.M_MOUSE_POSITION_BUFFER_Y, ref y);
            var imagePoint = new ImagePoint(x, y);
            curImagePoint.Text = imagePoint.ToString();

            if (_Calibrator != null) {
                var staticPoint = _Calibrator.TransformToCalibratedSpace(new ImagePoint(x, y), _ImageSize);
                curStaticPoint.Text = staticPoint.ToString();
            }
        }

        #region IDisposible
        public void Dispose() {
            if (!_Initialized) {
                return;
            }

            RemoveObservable();
            if (MilEnvironment.Instance.HasValidLicense()) {
                RemoveHookFunc();
                RemoveGraphics();
                FreeGraphics();
            }
            ClearGraEventSubscribers();

            _Initialized = false;
        }

        #region TrainRoi & FindRoi Changed Event
        private Dictionary<PatternInfo, IGraEventSubscriber> _GraEventSubscribers = new Dictionary<PatternInfo, IGraEventSubscriber>();

        public void SetGraEventSubscriber(PatternInfo patternInfo, object viewModel) {
            _GraEventSubscribers[patternInfo] = viewModel as IGraEventSubscriber;
        }

        private void ClearGraEventSubscribers() {
            _GraEventSubscribers.Clear();
        }

        private void SetTrainRoiChangedEvent() {
            RemoveTrainRoiChangedEvent();

            if (!_TrainRoiChangedDataHandle.IsAllocated) {
                if (_trainRoiLabel != MIL.M_NULL) {
                    _TrainRoiChangedDataHandle = GCHandle.Alloc(_trainRoiLabel);
                    _OnTrainRoiChangedFuncPtr = new MIL_GRA_HOOK_FUNCTION_PTR(OnTrainRoiChanged);
                    MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED, _OnTrainRoiChangedFuncPtr, GCHandle.ToIntPtr(_TrainRoiChangedDataHandle));
                }
            }
        }

        private void SetFindRoiChangedEvent(eRoiIdx roiIdx) {
            RemoveFindRoiChangedEvent(roiIdx);

            if (!_FindRoiChangedDataHandles[roiIdx].IsAllocated) {
                if (_findRoiLabels.ContainsKey(roiIdx) && _findRoiLabels[roiIdx] != MIL.M_NULL) {
                    _FindRoiChangedDataHandles[roiIdx] = GCHandle.Alloc(_findRoiLabels[roiIdx]);
                    _OnFindRoiChangedFuncPtrs[roiIdx] = new MIL_GRA_HOOK_FUNCTION_PTR(OnFindRoiChanged);
                    MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED,
                        _OnFindRoiChangedFuncPtrs[roiIdx], GCHandle.ToIntPtr(_FindRoiChangedDataHandles[roiIdx]));
                }
            }
        }

        private void RemoveTrainRoiChangedEvent() {
            if (_TrainRoiChangedDataHandle.IsAllocated) {
                MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED + MIL.M_UNHOOK, _OnTrainRoiChangedFuncPtr, GCHandle.ToIntPtr(_TrainRoiChangedDataHandle));
                _OnTrainRoiChangedFuncPtr = null;
                _TrainRoiChangedDataHandle.Free();
            }
        }

        private void SetTrainOriginChangedEvent() {
            RemoveTrainOriginChangedEvent();

            if (!_TrainOriginChangedDataHandle.IsAllocated) {
                if (_trainOriginLabel != MIL.M_NULL) {
                    _TrainOriginChangedDataHandle = GCHandle.Alloc(_trainOriginLabel);
                    _OnTrainOriginChangedFuncPtr = new MIL_GRA_HOOK_FUNCTION_PTR(OnTrainOriginChanged);
                    MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED, _OnTrainOriginChangedFuncPtr, GCHandle.ToIntPtr(_TrainOriginChangedDataHandle));
                }
            }
        }

        private void RemoveTrainOriginChangedEvent() {
            if (_TrainOriginChangedDataHandle.IsAllocated) {
                MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED + MIL.M_UNHOOK, _OnTrainOriginChangedFuncPtr, GCHandle.ToIntPtr(_TrainOriginChangedDataHandle));
                _OnTrainOriginChangedFuncPtr = null;
                _TrainOriginChangedDataHandle.Free();
            }
        }

        private MIL_INT OnTrainOriginChanged(MIL_INT HookType, MIL_ID EventId, IntPtr UserDataPtr) {
            try {
                if (_trainOriginLabel == MIL.M_NULL) {
                    return MIL.M_NULL;
                }

                if (!IntPtr.Zero.Equals(UserDataPtr)) {
                    MIL_INT curState = 0;
                    MIL.MgraGetHookInfo(EventId, MIL.M_INTERACTIVE_GRAPHIC_STATE, ref curState);

                    if (curState == MIL.M_STATE_GRAPHIC_HOVERED || curState == MIL.M_STATE_HANDLE_HOVERED) {
                        return MIL.M_NULL;
                    }

                    MIL_INT modifiedGraphicLabel = 0;
                    MIL.MgraGetHookInfo(EventId, MIL.M_GRAPHIC_LABEL_VALUE, ref modifiedGraphicLabel);

                    if (modifiedGraphicLabel == _trainOriginLabel) {
                        double radiusX = 0;
                        MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_X, ref radiusX);

                        if (radiusX > 500.0) {
                            radiusX = 500.0;
                            MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_X, 500.0);
                            MIL.MgraControlList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(_trainOriginLabel), MIL.M_DEFAULT, MIL.M_RADIUS_Y, 500.0);
                        }

                        if (_PatternInfos.ContainsKey(eRoiIdx.Roi0) && _GraEventSubscribers?.Count > 0) {
                            var patternInfo = _PatternInfos[eRoiIdx.Roi0];
                            if (_GraEventSubscribers.ContainsKey(patternInfo)) {
                                _GraEventSubscribers[patternInfo]?.UpdateRadiusOfRoi(eGraRoiType.TrainOrigin, radiusX);
                            }
                        }
                    }
                }
            }
            catch (Exception e) {
                _Logger?.FuncE(e.Message);
            }
            return MIL.M_NULL;
        }

        private void RemoveFindRoiChangedEvent(eRoiIdx roiIdx) {
            if (_FindRoiChangedDataHandles.ContainsKey(roiIdx) && _FindRoiChangedDataHandles[roiIdx].IsAllocated) {
                MIL.MgraHookFunction(StaticGraphicList, MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED + MIL.M_UNHOOK, _OnFindRoiChangedFuncPtrs[roiIdx], GCHandle.ToIntPtr(_FindRoiChangedDataHandles[roiIdx]));
                _OnFindRoiChangedFuncPtrs[roiIdx] = null;
                _FindRoiChangedDataHandles[roiIdx].Free();
            }
            _FindRoiChangedDataHandles[roiIdx] = new GCHandle();
        }

        private MIL_INT OnTrainRoiChanged(MIL_INT HookType, MIL_ID EventId, IntPtr UserDataPtr) {
            return DoRoiChangedAction(eGraRoiType.TrainRoi, _trainRoiLabel, EventId, UserDataPtr);
        }

        private MIL_INT OnFindRoiChanged(MIL_INT HookType, MIL_ID EventId, IntPtr UserDataPtr) {
            if (HookType == MIL.M_INTERACTIVE_GRAPHIC_STATE_MODIFIED) {
                GCHandle retrievedHandle = GCHandle.FromIntPtr(UserDataPtr);
                MIL_ID graphicLabel = (MIL_ID)retrievedHandle.Target;

                if (_findRoiLabels.ContainsValue(graphicLabel)) {
                    eRoiIdx roiIdx = _findRoiLabels.Where(x => x.Value == graphicLabel).Select(x => x.Key).FirstOrDefault();
                    return DoRoiChangedAction(eGraRoiType.FindRoi, graphicLabel, EventId, UserDataPtr, roiIdx);
                }
            }
            return MIL.M_NULL;
        }

        private MIL_INT DoRoiChangedAction(
            eGraRoiType graRoiType, MIL_ID label, MIL_ID EventId, IntPtr UserDataPtr, eRoiIdx roiIdx = eRoiIdx.Roi0) {

            try {
                if (label == MIL.M_NULL) {
                    return MIL.M_NULL;
                }

                MIL_INT isRotatable = 0;
                MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(label), MIL.M_DEFAULT, MIL.M_ROTATABLE, ref isRotatable);

                if (isRotatable == MIL.M_DISABLE) {
                    return MIL.M_NULL;
                }

                if (!IntPtr.Zero.Equals(UserDataPtr)) {
                    MIL_INT curState = 0;
                    MIL.MgraGetHookInfo(EventId, MIL.M_INTERACTIVE_GRAPHIC_STATE, ref curState);

                    // M_STATE_HANDLE_HOVERED, M_STATE_HANDLE_DRAGGED 필터링시, 두번째 클릭시 InterActive가 해제되는 문제가 있었음.
                    if (curState == MIL.M_STATE_GRAPHIC_HOVERED) {
                        ROI findRoi = GetFindRoi(roiIdx);
                        AddFindRoiLabelNum(findRoi, roiIdx);
                        return MIL.M_NULL;
                    }
                    if (curState == MIL.M_STATE_IDLE) {
                        return MIL.M_NULL;
                    }

                    MIL_INT modifiedGraphicLabel = 0;
                    MIL.MgraGetHookInfo(EventId, MIL.M_GRAPHIC_LABEL_VALUE, ref modifiedGraphicLabel);

                    if (modifiedGraphicLabel == label) {
                        double angle = 0;
                        MIL.MgraInquireList(StaticGraphicList, MIL.M_GRAPHIC_LABEL(label), MIL.M_DEFAULT, MIL.M_ANGLE, ref angle);
                        if (_GraEventSubscribers?.Count > 0) {
                            _GraEventSubscribers[_PatternInfos[roiIdx]]?.UpdateAngleOfRoi(graRoiType, angle);
                        }
                    }
                }
            }
            catch (Exception e) {
                _Logger.FuncE(e.Message);
            }
            return MIL.M_NULL;
        }
        #endregion

        private void RemoveHookFunc() {
            RemoveTrainRoiChangedEvent();
            RemoveTrainOriginChangedEvent();
            for (int i = 0; i < _FindRoiChangedDataHandles.Count; i++) {
                RemoveFindRoiChangedEvent((eRoiIdx)i);
            }

            if (ThisPtr.IsAllocated) {
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_LEFT_BUTTON_DOWN + MIL.M_UNHOOK, MouseLeftDownHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_MOVE + MIL.M_UNHOOK, MouseLeftMoveHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_RIGHT_BUTTON_DOWN + MIL.M_UNHOOK, MouseRightDownHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MdispHookFunction(DisplayId, MIL.M_MOUSE_WHEEL + MIL.M_UNHOOK, MouseWheelHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
                MIL.MgraHookFunction(StaticGraphicList, MIL.M_GRAPHIC_SELECTION_MODIFIED + MIL.M_UNHOOK, GraphicSelectionModifiedHookFuncPtr, GCHandle.ToIntPtr(ThisPtr));
            }

            ThisPtr.Free();
            MouseLeftDownHookFuncPtr = null;
            MouseLeftMoveHookFuncPtr = null;
            MouseRightDownHookFuncPtr = null;
            GraphicSelectionModifiedHookFuncPtr = null;
        }

        private void RemoveGraphics() {
            _patternResultGraphics = null;
            _trainGraphics = null;
            _findGraphics = null;
            _findLabelNumGraphicsDic.Clear();
            _gridGuideLine = null;
        }

        private void RemoveObservable() {
            _EventDisposable?.Dispose();
            _EventDisposable = null;
        }

        private void FreeGraphics() {
            MIL.MbufFree(ImageId);
            MIL.MgraFree(GraphicContext);
            MIL.MgraFree(StaticGraphicList);
            MIL.MdispFree(DisplayId);
        }
        #endregion
    }
}