using CoreUnit.Control.UserControl.Canvas;
using CoreUnit.Scanner.UserControl.ScannerCanvas;
using Matrox.MatroxImagingLibrary;
using OpenCvSharp;
using OpenCvSharp.WpfExtensions;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Windows;
using System.Windows.Media.Imaging;
using Logger = Aurora.Api.Logger;
using System.Diagnostics;
using WeldingCommon.Vision.WeldingObjectGenerator.PathEditorLibrary;
using WeldingCommon.Data;
using WeldingCommon.Utils;
using LiveChartsCore.Drawing;

namespace WeldingCommon.Vision.WeldingObjectGenerator
{
    using TPolygon = List<GeometryLibrary.TPoint>;
    using TPoint = GeometryLibrary.TPoint;
    using Vector2 = GeometryLibrary.Vector2;
    using Canvas = CoreUnit.Control.UserControl.Canvas;
    using static CoreUnit.Control.UserControl.Canvas.WeldingParameterIDEditor;
    using static OpenCvSharp.LineIterator;
    using static System.Windows.Forms.VisualStyles.VisualStyleElement.Menu;
    using Point = OpenCvSharp.Point;
    using Size = OpenCvSharp.Size;

    // Pixel Data 로부터 Welding Object 를 생성하는 Path List 를 만드는 Class
    public class ObjectGenerator
    {
        #region Properties

        private readonly Logger Log = new Logger("WeldingObjectGenerator");

        private TPolygon polygon;
        private TPolygon merged_polygon;
        private TPolygon rearranged_polygon;
        private PathEditor patheditor;

        List<PathItem> paths;

        public double dMergeDist { get; set; }
        public uint nMaxArcRadius { get; set; }
        public uint nLineTolerance { get; set; }
        public uint nArcTolerance { get; set; }
        public float fLineDefualtWidth { get; set; }
        public Int64 nImageWidth { get; set; }
        public Int64 nImageHeight { get; set; }
        public double PixelResolution { get; set; }
        public double DrawingImageCenterOffsetX { get; set; }
        public double DrawingImageCenterOffsetY { get; set; }

        public double dInterlockArcLength { get; set; }
        public double dInterlockDistRange { get; set; }
        public double dInterlockLengthDiffRange { get; set; }
        public double dPathLengthSum { get; set; }
        public double dInterlockCenterXYDiffRange { get; set; }
        public double eInterlockMaxMinDiff { get; set; }
        public double eInterlockMaxMinDiff_local { get; set; }
        public UnitPoint DetectedContourCenter;
        public UnitPoint DetectedContourCenterPixel;
        public float fDetectedContourRadius;
        #endregion

        private double[] theta_list = new double[36000];
        private double[] offset_list = new double[36000];
        private bool is_manual = true;
        private int end_point_index = 0;

        #region Original Path 의 정보를 가진 properties
        public Arc m_OriginArc;
        private bool bArcHasRamping;            // m_OriginArc 가 Ramping 을 하는 경우 true
        private stRampingInfo m_RampingStartInfo;
        private stRampingInfo m_RampingEndInfo;
        struct stRampingInfo
        {
            public int m_Count;             // Ramping Count
            public double length;           // Ramping 전체 구간 길이
            public double Intervallength;   // 1-count 의 원호 길이. rampling 의 전체 길이 / Ramping Count 임. parameter 에 인터벌 값을 직접 입력해서 쓰는듯.
            public double PowerRatioCh1;    // center power 비율. 100% 는 고정이므로 시작점, 끝점만 알면 된다. range(0~100)
            public double PowerRatioCh2;    // ring power 비율. 100% 는 고정이므로 시작점, 끝점만 알면 된다. range(0~100)
        }
        #endregion

        public ObjectGenerator()
        {
            polygon = new TPolygon();
            patheditor = new PathEditor();

            // Defualt setting. sw 의 setting parameter 에서 넣도록 하자.
            dMergeDist = 10.0;
            nMaxArcRadius = 1000;
            nLineTolerance = 10;
            nArcTolerance = 10;
            fLineDefualtWidth = 0.01f;
            PixelResolution = 1.0f; // setting 에서 가져올것
            nImageWidth = 0; nImageHeight = 0;  // image 생성한 후에 넣을수 있으므로 바뀔수 있음
            DrawingImageCenterOffsetX = 0; DrawingImageCenterOffsetY = 0;
            dInterlockDistRange = 1.0;
            dInterlockArcLength = 10.0;
            eInterlockMaxMinDiff = 20;
            eInterlockMaxMinDiff_local = 10;
        }

        public ObjectGenerator(Int64 nWidth, Int64 nHeight, double dPixelResolution, double dDrawingImageCenterOffsetX = 0, double dDrawingImageCenterOffsetY = 0)
        {
            polygon = new TPolygon();
            patheditor = new PathEditor();

            // Defualt setting. sw 의 setting parameter 에서 넣도록 하자.
            dMergeDist = 10.0;
            nMaxArcRadius = 1000;
            nLineTolerance = 10;
            nArcTolerance = 10;
            fLineDefualtWidth = 0.01f;
            nImageWidth = nWidth; nImageHeight = nHeight;  // image 생성한 후에 넣을수 있으므로 바뀔수 있음
            PixelResolution = dPixelResolution;
            DrawingImageCenterOffsetX = 0; DrawingImageCenterOffsetY = 0;
            dInterlockDistRange = 1.0;
            dInterlockArcLength = 10.0;
            eInterlockMaxMinDiff = 20;
            eInterlockMaxMinDiff_local = 10;
        }

        public void SetOffsetType(string offsetType)
        {
            if (offsetType == "Manual")
                is_manual = true;
            else
                is_manual = false;
        }

        public void SetInterlockProperties(double DistRange, double dArcLength, double dPathLengthSumRange, double dCenterXYDiffRange)
        {
            if (DistRange < 0 || dArcLength < 0) {
                dInterlockDistRange = 1.0;
                return;
            }

            dInterlockDistRange = DistRange;
            dInterlockArcLength = dArcLength;
            dInterlockLengthDiffRange = dPathLengthSumRange;
            dInterlockCenterXYDiffRange = dCenterXYDiffRange;
        }

        public void SetImageSize(Int64 nWidth, Int64 nHeight)
        {
            nImageWidth = nWidth; nImageHeight = nHeight;  // image 생성한 후에 넣을수 있으므로 바뀔수 있음
        }

        public void SetdPixelResolution(double dPixelResolution, double dDrawingImageCenterOffsetX = 0, double dDrawingImageCenterOffsetY = 0)
        {
            PixelResolution = dPixelResolution;
            DrawingImageCenterOffsetX = dDrawingImageCenterOffsetX;
            DrawingImageCenterOffsetY = dDrawingImageCenterOffsetY;
        }
        public void SetDrawingImageCenterOffset(double dDrawingImageCenterOffsetX, double dDrawingImageCenterOffsetY)
        {
            DrawingImageCenterOffsetX = dDrawingImageCenterOffsetX;
            DrawingImageCenterOffsetY = dDrawingImageCenterOffsetY;
        }

        public bool SetPolygonFromFile(string strfilename)
        {
            // csv file 로 부터 읽어온다.
            // 줄단위로 읽어서 앞의 숫자 2개를 x,y 좌표로 하는 List 양식을 polygon 에 넣어준다.
            try {
                Stream rs = new FileStream(strfilename, FileMode.Open);
                StreamReader sr = new StreamReader(rs);

                polygon.Clear();

                while (!sr.EndOfStream) {
                    String s = sr.ReadLine();
                    string[] words = s.Split(',');
                    polygon.Add(new TPoint(Int32.Parse(words[0]), Int32.Parse(words[1])));
                }
                return true;

            } catch (Exception e) {
                MessageBox.Show(e.Message);
                return false;
            }
        }

        public void SetPolygonFromList(List<GeometryLibrary.TPoint> list)
        {
            polygon = list;
        }
        public void SetPolygonFromList(List<OpenCvSharp.Point> list)
        {
            // 2point double list 변수를 TPoint 에 넣는다. 정수형으로 바꿔주므로 정보손실은 있다.
            polygon.Clear();
            foreach (var item in list) {
                polygon.Add(new TPoint(Convert.ToInt32(item.X), Convert.ToInt32(item.Y)));
            }
        }
        public void SetPolygonFromList(OpenCvSharp.Point[][] list)
        {
            // 2point double list 변수를 TPoint 에 넣는다. 정수형으로 바꿔주므로 정보손실은 있다.
            polygon.Clear();
            for (int i = 0; i < list.Length; i++)
                for (int j = 0; j < list[i].Length; j++)
                    polygon.Add(new TPoint(Convert.ToInt32(list[i][j].X), Convert.ToInt32(list[i][j].Y)));
        }
        public void ClearPolygonData()
        {
            polygon.Clear();
        }
        public void CalculateAutoPathAngle(int ObjectN)
        {
            MergePolygonSample(dMergeDist);
            patheditor.GeneratePathWDegree(merged_polygon, ObjectN, end_point_index);
            paths = patheditor.GetAutoPathItem();

        }

        public void CalculateAutoPath(double dMergeDist, uint nMaxArcRadius, uint nLineTolerance, uint nArcTolerance)
        {
            MergePolygonSample(dMergeDist);
            ReArrangePoints();
            patheditor.GenerateAutoPath(rearranged_polygon, nMaxArcRadius, nLineTolerance, nArcTolerance, (UInt32)DetectedContourCenterPixel.X, (UInt32)DetectedContourCenterPixel.Y);
            paths = patheditor.GetAutoPathItem();
        }

        public void CalculateAutoPath(double dMergeDist, uint nMaxArcRadius, uint nLineTolerance, uint nArcTolerance, double dRampingStartLength, double dRampingEndLength)
        {
            MergePolygonSample(dMergeDist);
            ReArrangePoints();
            patheditor.GenerateAutoPath(rearranged_polygon, nMaxArcRadius, nLineTolerance, nArcTolerance, (UInt32)DetectedContourCenterPixel.X, (UInt32)DetectedContourCenterPixel.Y);
            paths = patheditor.GetAutoPathItem();

        }

        private void SplitReArrangedPolygonbyRampingLength(double dRampingStartLength, double dRampingEndLength, out List<TPolygon> lsRearrangedPolygon)
        {
            // 현재는 안쓴다. 나중을 위해서 남겨둔다.
            // rearranged_polygon 를 길이로 해서 3개로 쪼갠 list 로 바꿔준다.
            // 쪼갤때 end point 를 다음 list 의 start 와 겹쳐지도록 할 것.
            // dRampingStartLength, dRampingEndLength 는 mm 단위로 받아서 이 함수내에서 pixel 로 바꿔준다

            lsRearrangedPolygon = new List<TPolygon>();

            if (PixelResolution == 0)
                return;
            double dRampingStartPixelLength = dRampingStartLength / PixelResolution;
            double dRampingEndPixelLength = dRampingEndLength / PixelResolution;

            int RampingStartFinalIndex = 0;
            int RampingEndFinalIndex = 0;

            double dCalStartDist = 0.0;
            for (int i = 1; i < rearranged_polygon.Count; i++) {
                double distx = rearranged_polygon[i].x - rearranged_polygon[i - 1].x;
                double disty = rearranged_polygon[i].y - rearranged_polygon[i - 1].y;
                dCalStartDist += Math.Sqrt(distx * distx + disty * disty);
                if (dCalStartDist > dRampingStartPixelLength) {
                    RampingStartFinalIndex = i;
                    break;
                }
            }

            double dCalEndDist = 0.0;

            for (int i = rearranged_polygon.Count - 1; i > 1; i--) {
                double distx = rearranged_polygon[i].x - rearranged_polygon[i - 1].x;
                double disty = rearranged_polygon[i].y - rearranged_polygon[i - 1].y;
                dCalEndDist += Math.Sqrt(distx * distx + disty * disty);
                if (dCalEndDist > dRampingEndPixelLength) {
                    RampingEndFinalIndex = i;
                    break;
                }
            }

            lsRearrangedPolygon.Add(rearranged_polygon.GetRange(0, RampingStartFinalIndex));
            lsRearrangedPolygon.Add(rearranged_polygon.GetRange(RampingStartFinalIndex - 1, RampingEndFinalIndex - RampingStartFinalIndex + 2));   // point 겹쳐지게 시작위치를 1칸 당기고 끝나는 위치를 1칸 늘린다
            lsRearrangedPolygon.Add(rearranged_polygon.GetRange(RampingEndFinalIndex, rearranged_polygon.Count - RampingEndFinalIndex));
        }

        public void GetAutoPath(out List<PathItem> lsPaths)
        {
            lsPaths = paths;
        }

        public void ConvertPixelAxisFromDrawingObjectAxis(UnitPoint DOPoint, out double pixelX, out double pixelY)
        {
            // ConvertDrawingObjectAxis 의 역함수 구하자.
            pixelX = (DOPoint.X - DrawingImageCenterOffsetX) / PixelResolution + nImageWidth / 2;
            pixelY = -((DOPoint.Y - DrawingImageCenterOffsetY) / PixelResolution - nImageHeight / 2);
        }

        public void ConvertDrawingObjectAxis(Int64 pixelX, Int64 pixelY, out UnitPoint UPDest)
        {
            // Pixel 로 된 좌표계를 Drawing Object 의 좌표계로 변환. 스캐너의 레졸루션까지 반영되지는 않았다.
            // Pixel resolution x, y 가 다르면 Radius 계산이 매우 어려워진다. vector 방향에 따라서 resoultion 계산을 따로 해줘야하기 때문
            UnitPoint up = new UnitPoint();
            double dPixelX = Convert.ToDouble(pixelX) - nImageWidth / 2;
            double dPixelY = -Convert.ToDouble(pixelY) + nImageHeight / 2;
            up.X = dPixelX * PixelResolution + DrawingImageCenterOffsetX;
            up.Y = dPixelY * PixelResolution + DrawingImageCenterOffsetY;
            UPDest = up;
        }
        public void ConvertDrawingObjectAxis(float pixelX, float pixelY, out UnitPoint UPDest)
        {
            // Pixel 로 된 좌표계를 Drawing Object 의 좌표계로 변환. 스캐너의 레졸루션까지 반영되지는 않았다.
            // Pixel resolution x, y 가 다르면 Radius 계산이 매우 어려워진다. vector 방향에 따라서 resoultion 계산을 따로 해줘야하기 때문
            UnitPoint up = new UnitPoint();
            double dPixelX = Convert.ToDouble(pixelX) - nImageWidth / 2;
            double dPixelY = -Convert.ToDouble(pixelY) + nImageHeight / 2;
            up.X = dPixelX * PixelResolution + DrawingImageCenterOffsetX;
            up.Y = dPixelY * PixelResolution + DrawingImageCenterOffsetY;
            UPDest = up;
        }

        public void ConvertDrawingObjectAxis(Int32 pixel, out float dDest)
        {
            // Pixel 로 된 좌표계를 Drawing Object 의 좌표계로 변환. 스캐너의 레졸루션까지 반영되지는 않았다.
            // Pixel resolution x, y 가 다르면 Radius 계산이 매우 어려워진다. vector 방향에 따라서 resoultion 계산을 따로 해줘야하기 때문
            // data 손실 주의..
            dDest = (float)(Convert.ToDouble(pixel) * PixelResolution);
        }
        public void ConvertDrawingObjectAxis(float pixel, out float dDest)
        {
            // Pixel 로 된 좌표계를 Drawing Object 의 좌표계로 변환. 스캐너의 레졸루션까지 반영되지는 않았다.
            // Pixel resolution x, y 가 다르면 Radius 계산이 매우 어려워진다. vector 방향에 따라서 resoultion 계산을 따로 해줘야하기 때문
            // data 손실 주의..
            dDest = pixel * (float)PixelResolution;
        }

        private void ConvertPathArcToDrawingArc(PathItem item, out Arc arc)
        {
            arc = new Arc();
            UnitPoint dCenterPoint, dStartPoint, dEndPoint;
            Int64 lx, ly;

            arc.Direction = m_OriginArc.Direction;
            item.GetCenter(out lx, out ly);
            ConvertDrawingObjectAxis(lx, ly, out dCenterPoint);
            arc.Center = dCenterPoint;

            item.GetStart(out lx, out ly);
            ConvertDrawingObjectAxis(lx, ly, out dStartPoint);
            item.GetEnd(out lx, out ly);
            ConvertDrawingObjectAxis(lx, ly, out dEndPoint);

            float radius;
            ConvertDrawingObjectAxis(Convert.ToInt32(item.GetRadius()), out radius);
            arc.Radius = radius;

            double dStartAngle = Math.Atan2((dStartPoint.Y - dCenterPoint.Y), (dStartPoint.X - dCenterPoint.X)) * (180 / Math.PI);
            // arc.StartAngle 는 0~360 범위가 아니면 입력자체가 안된다.
            if (dStartAngle < 0) dStartAngle += 360.0f;
            arc.StartAngle = (float)dStartAngle;

            double dEndAngle = Math.Atan2((dEndPoint.Y - dCenterPoint.Y), (dEndPoint.X - dCenterPoint.X)) * (180 / Math.PI);
            if (dEndAngle < 0.0) arc.EndAngle = (float)(dEndAngle + 360.0);
            else arc.EndAngle = (float)dEndAngle;




            //double dCenterDist = Math.Sqrt(dCenterPoint.X * dCenterPoint.X + dCenterPoint.Y * dCenterPoint.Y);
            //double dStartDist = Math.Sqrt(dStartPoint.X * dStartPoint.X + dStartPoint.Y * dStartPoint.Y);

            //if (dCenterDist > dStartDist)
            //{
            //    arc.Direction = Arc.eDirection.CW;
            //}
            //else
            //{
            //    arc.Direction = Arc.eDirection.CCW;
            //}


            // Radius 가 큰 경우는 무조건 예각만 가능하다. 크다는 기준은? Cell 의 50% 이상으로 일단 설정해봄
            //if (/*arc.Radius > dStartDist*0.5 && */Math.Abs(arc.SweepAngle) > 180.0)
            //{
            //    //Direction 바꿔주고 EndAngle 을 재설정해주자. 그러면 SweepAngle 재설정된다.
            //    arc.Direction = arc.Direction == Arc.eDirection.CCW ? Arc.eDirection.CW : Arc.eDirection.CCW;
            //    arc.EndAngle = (float)dEndAngle;
            //}
        }

        public void ConvertPathItemToDrawingObjects(float fLineDefualtWidth, out List<IDrawObject> destDrawObjects)
        {
            List<IDrawObject> ConvertedDrawObjects = new List<IDrawObject>();
            int no = 0;
            foreach (var item in paths) {
                if (item.GetType() == PathItem._PathType.Line) {
                    UnitPoint dStartPoint, dEndPoint;
                    Int64 lx, ly;
                    item.GetStart(out lx, out ly);
                    ConvertDrawingObjectAxis(lx, ly, out dStartPoint);
                    item.GetEnd(out lx, out ly);
                    ConvertDrawingObjectAxis(lx, ly, out dEndPoint);

                    Canvas.Line lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);
                    lineitem.No = no;
                    lineitem.MadebyRCC = true;
                    ConvertedDrawObjects.Add(lineitem);
                    // parameter ID 는 어떻게?
                } else if (item.GetType() == PathItem._PathType.Arc) {
                    Canvas.Arc arcitem;

                    ConvertPathArcToDrawingArc(item, out arcitem);
                    arcitem.No = no;
                    arcitem.MadebyRCC = true;
                    //if(ConvertedDrawObjects.Count > 1)
                    //{
                    //    arcitem.PF1 = ConvertedDrawObjects[ConvertedDrawObjects.Count - 1].PF2;
                    //}
                    ConvertedDrawObjects.Add(arcitem);

                } else {
                    // 이런 경우 없다
                }
                no++;
            }
            //Ramping 사용하지 않을 경우
            //destDrawObjects = ConvertedDrawObjects;

            //Ramping 사용할 경우
            SplitDrawingObjectRampingInterval(ConvertedDrawObjects, out destDrawObjects);
        }

        public void SplitDrawingObjectRampingInterval(List<IDrawObject> srcDrawObjects, out List<IDrawObject> destDrawObjects)
        {
            //Ramping 사용 시 End만 사용할 때 시작 객체가 사라지는 문제 발생
            if (bArcHasRamping == false) {
                destDrawObjects = srcDrawObjects;
                return;
            }
            destDrawObjects = new List<IDrawObject>();
            int no = 0;

            // 길이를 단위길이로 나눴을때 나머지 구하는 람다함수
            Func<double, double, double> remainder = (dividend, divisor) => dividend - (Math.Floor(dividend / divisor) * divisor);
            // 길이를 단위길이로 나눴을때 몫을 구하는 람다함수. step 갯수를 구하기 위함.
            Func<double, double, int> floor = (dividend, divisor) => Convert.ToInt32(Math.Floor(dividend / divisor));

            double dStartRampingLengthSum = 0;      // 누적합을 저장해뒀다가 start 전체 length 에 도달하면 완료.
            double dEndRampingLengthSum = 0;      // 누적합을 저장해뒀다가 start 전체 length 에 도달하면 완료.
            double dRampingResidueLength = 0;       // 예를 들면 0.1mm interval 인데 채운 object 길이가 0.07mm 였다면 0.03mm 가 모자란다. 다음번에 0.03mm 채울값을 여기에 저장.
            int rampingstartfinishedindex = 0;
            int rampingendbeginindex = 0;


            // raming start 구간이 끝나는 index 를 먼저 찾는다.
            for (int i = 0; i < srcDrawObjects.Count; i++) {
                double objlength = 0;
                if (srcDrawObjects[i] is Line) objlength = ((Line)srcDrawObjects[i]).Distance;
                else objlength = ((Arc)srcDrawObjects[i]).Length;
                dStartRampingLengthSum += objlength;
                if (dStartRampingLengthSum > m_RampingStartInfo.length) {
                    rampingstartfinishedindex = i;
                    break;
                }
            }
            // raming end 구간이 시작되는 index 를 먼저 찾는다.
            double dEndrampingPreDistance = 0;
            for (int i = srcDrawObjects.Count - 1; i >= 0; i--) {
                double objlength = 0;
                if (srcDrawObjects[i] is Line) objlength = ((Line)srcDrawObjects[i]).Distance;
                else objlength = ((Arc)srcDrawObjects[i]).Length;
                dEndRampingLengthSum += objlength;
                if (dEndRampingLengthSum > m_RampingEndInfo.length) {
                    rampingendbeginindex = i;
                    dEndrampingPreDistance = dEndRampingLengthSum - m_RampingEndInfo.length;
                    break;
                }
            }
            dStartRampingLengthSum = 0;
            dEndRampingLengthSum = 0;


            // ramping start 구간
            // 앞쪽부터 채운다.
            if (m_RampingStartInfo.length > 0) {
                for (int i = 0; i <= rampingstartfinishedindex; i++) {
                    if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                        dRampingResidueLength = 0;
                        break;
                    }
                    var obj = srcDrawObjects[i];

                    if (obj is Line) {
                        UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                        UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                        Canvas.Line lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);

                        if (dRampingResidueLength > 0) {
                            // 전회차에 남은 거리를 object 로 만들어줬다면 모자란 만큼을 처음 object 로 만들어준다.

                            if (lineitem.Distance < dRampingResidueLength) {
                                // 다음 object 가 모자란 양을 다 못채우는 경우. 즉, 길이가 더 짧은 경우임. (사실상 ramping interval 이 더 짧아서 이런경우는 없을듯)
                                dRampingResidueLength -= lineitem.Distance;
                                lineitem.No = no++;
                                lineitem.MadebyRCC = true;
                                destDrawObjects.Add(lineitem);
                                dStartRampingLengthSum += lineitem.Distance;
                                continue;
                            } else {
                                lineitem.Distance = dRampingResidueLength;
                                dRampingResidueLength = 0;
                                lineitem.No = no++;
                                lineitem.MadebyRCC = true;
                                destDrawObjects.Add(lineitem);
                                dStartRampingLengthSum += lineitem.Distance;
                                dStartPoint = new UnitPoint(lineitem.PF2);

                                if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                                    // 구간길이를 모두 채우면 다음 object 이어 붙이고 종료
                                    lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);
                                    // Ramping Object 아님
                                    lineitem.No = no++;
                                    lineitem.MadebyRCC = true;
                                    destDrawObjects.Add(lineitem);
                                    dRampingResidueLength = 0;
                                    break;
                                }
                            }
                        }

                        lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.
                                                                                                           // 중간지점 interval 길이만큼 반복으로 채워준다.
                        while (lineitem.Distance > m_RampingStartInfo.Intervallength) {
                            lineitem.Distance = m_RampingStartInfo.Intervallength;
                            dRampingResidueLength = 0;
                            lineitem.No = no++;
                            lineitem.MadebyRCC = true;
                            destDrawObjects.Add(lineitem);
                            dStartRampingLengthSum += lineitem.Distance;
                            dStartPoint = new UnitPoint(lineitem.PF2);
                            lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.

                            if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                                // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                                dRampingResidueLength = 0;
                                break;
                            }
                        }

                        // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                        lineitem.No = no++;
                        lineitem.MadebyRCC = true;
                        destDrawObjects.Add(lineitem);
                        dStartRampingLengthSum += lineitem.Distance;

                        if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            break;
                        } else {
                            // 여기까지오면 interval 보다 짧은 구간만 남는다. 채워넣어주고 모자란 길이를 residue 로 기록하자.
                            dRampingResidueLength = m_RampingStartInfo.Intervallength - lineitem.Distance;
                        }

                    } else if (obj is Arc) {
                        UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                        UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                        Canvas.Arc arcitem = (Canvas.Arc)obj.Clone();

                        if (dRampingResidueLength > 0) {
                            // 전회차에 남은 거리를 object 로 만들어줬다면 모자란 만큼을 처음 object 로 만들어준다.

                            if (arcitem.Length < dRampingResidueLength) {
                                // 다음 object 가 모자란 양을 다 못채우는 경우. 즉, 길이가 더 짧은 경우임. (사실상 ramping interval 이 더 짧아서 이런경우는 없을듯)
                                dRampingResidueLength -= arcitem.Length;
                                arcitem.No = no++;
                                arcitem.MadebyRCC = true;
                                destDrawObjects.Add(arcitem);
                                dStartRampingLengthSum += arcitem.Length;
                                continue;
                            } else {
                                dEndPoint = new UnitPoint(arcitem.PF2.X, arcitem.PF2.Y);
                                arcitem.Length = (float)dRampingResidueLength;
                                dRampingResidueLength = 0;
                                arcitem.No = no++;
                                arcitem.MadebyRCC = true;
                                destDrawObjects.Add(arcitem);
                                dStartRampingLengthSum += (double)(arcitem.Length);
                                dStartPoint = new UnitPoint(arcitem.PF2);

                                if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                                    // 구간길이를 모두 채우면 다음 object 이어 붙이고 종료
                                    arcitem = (Canvas.Arc)obj.Clone();
                                    arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                                    arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);
                                    // Ramping Object 아님
                                    arcitem.No = no++;
                                    arcitem.MadebyRCC = true;
                                    destDrawObjects.Add(arcitem);
                                    dRampingResidueLength = 0;
                                    break;
                                }
                            }
                        }

                        arcitem = (Canvas.Arc)obj.Clone(); arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.

                        // 중간지점 interval 길이만큼 반복으로 채워준다.
                        while (arcitem.Length > m_RampingStartInfo.Intervallength) {
                            dEndPoint = new UnitPoint(arcitem.PF2.X, arcitem.PF2.Y);
                            arcitem.Length = (float)m_RampingStartInfo.Intervallength;
                            dRampingResidueLength = 0;
                            arcitem.No = no++;
                            arcitem.MadebyRCC = true;
                            destDrawObjects.Add(arcitem);
                            dStartRampingLengthSum += arcitem.Length;
                            dStartPoint = new UnitPoint(arcitem.PF2);
                            arcitem = (Canvas.Arc)obj.Clone();
                            arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                            arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);

                            if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                                // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                                dRampingResidueLength = 0;
                                break;
                            }
                        }

                        // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                        arcitem.No = no++;
                        arcitem.MadebyRCC = true;
                        destDrawObjects.Add(arcitem);
                        dStartRampingLengthSum += arcitem.Length;

                        if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            rampingstartfinishedindex = i;
                            break;
                        } else {
                            // 여기까지오면 interval 보다 짧은 구간만 남는다. 채워넣어주고 모자란 길이를 residue 로 기록하자.
                            dRampingResidueLength = m_RampingStartInfo.Intervallength - arcitem.Length;
                        }
                    } else {
                        // 없음
                    }
                }
            } else {
                //StartRamping을 안쓸경우 rampingstartfinishedindex를 0번부터 만들어줘야하는데.. 쓸 경우는 아래 for문에서 +1을 줘야하니깐 여기서 빼주자
                rampingstartfinishedindex -= 1;
            }

            // no ramping 구간
            // addrange 를 쓰면 속성값을 입력할 수 없다. for loop 로 변경한다.
            //List<IDrawObject> NoRampingtDrawObjects = srcDrawObjects.GetRange(rampingstartfinishedindex+1, rampingendbeginindex - rampingstartfinishedindex);
            //destDrawObjects.AddRange(NoRampingtDrawObjects);

            //startramping만 사용할 때 rampingendbeginindex를 +1 해주지않으면 마지막객체가 생성되지 않음
            if (m_RampingStartInfo.length > 0 && m_RampingEndInfo.length == 0)
                rampingendbeginindex += 1;

            for (int i = rampingstartfinishedindex + 1; i < rampingendbeginindex; i++) {

                var obj = srcDrawObjects[i];
                obj.No = no++;

                if (obj is Line) {
                    ((Line)obj).MadebyRCC = true;
                } else if (obj is Arc) {
                    ((Arc)obj).MadebyRCC = true;
                } else {
                    // 이런 경우가 없음 여기로 오면 예외처리 할 것.
                }
                destDrawObjects.Add(obj);
            }


            if (m_RampingEndInfo.length > 0) {
                // ramping end 구간
                List<IDrawObject> RampingEndtDrawObjects = new List<IDrawObject>();

                // ramping end 구간 첫번째 item 은 별도로 처리. ramping 이 아닌곳과 ramping 인곳이 섞여있음.
                dRampingResidueLength = 0;
                dEndRampingLengthSum = 0;
                var obj = srcDrawObjects[rampingendbeginindex];
                // ramping 아닌 구간을 먼저 채운다.
                if (obj is Line) {
                    UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                    UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                    Canvas.Line lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);
                    // dEndrampingPreDistance
                    lineitem.Distance = dEndrampingPreDistance;
                    dRampingResidueLength = 0;
                    lineitem.No = no++;
                    lineitem.MadebyRCC = true;
                    destDrawObjects.Add(lineitem);
                    dStartPoint = new UnitPoint(lineitem.PF2);

                    lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.
                                                                                                       // 중간지점 interval 길이만큼 반복으로 채워준다.
                    while (lineitem.Distance > m_RampingEndInfo.Intervallength) {
                        lineitem.Distance = m_RampingEndInfo.Intervallength;
                        dRampingResidueLength = 0;
                        lineitem.No = no++;
                        lineitem.MadebyRCC = true;
                        destDrawObjects.Add(lineitem);
                        dEndRampingLengthSum += lineitem.Distance;
                        dStartPoint = new UnitPoint(lineitem.PF2);
                        lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.

                        if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            break;
                        }
                    }

                    // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                    lineitem.No = no++;
                    lineitem.MadebyRCC = true;
                    destDrawObjects.Add(lineitem);
                    dEndRampingLengthSum += lineitem.Distance;

                    if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                        // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                        dRampingResidueLength = 0;
                    } else {
                        // 여기까지오면 interval 보다 짧은 구간만 남는다. 채워넣어주고 모자란 길이를 residue 로 기록하자.
                        dRampingResidueLength = m_RampingEndInfo.Intervallength - lineitem.Distance;
                    }
                } else if (obj is Arc) {
                    UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                    UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                    Canvas.Arc arcitem = (Canvas.Arc)obj.Clone();

                    // ramping 이 아닌 구간을 먼저 넣어줌
                    arcitem.Length = (float)dEndrampingPreDistance;
                    dRampingResidueLength = 0;
                    arcitem.No = no++;
                    arcitem.MadebyRCC = true;
                    destDrawObjects.Add(arcitem);
                    dStartPoint = new UnitPoint(arcitem.PF2);

                    arcitem = (Canvas.Arc)obj.Clone();
                    arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                    arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);

                    // 여기부터 ramping 구간
                    while (arcitem.Length > m_RampingEndInfo.Intervallength) {
                        arcitem.Length = (float)m_RampingEndInfo.Intervallength;
                        dRampingResidueLength = 0;
                        arcitem.No = no++;
                        arcitem.MadebyRCC = true;
                        destDrawObjects.Add(arcitem);
                        dEndRampingLengthSum += arcitem.Length;
                        dStartPoint = new UnitPoint(arcitem.PF2);
                        arcitem = (Canvas.Arc)obj.Clone();
                        arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                        arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);

                        if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            break;
                        }
                    }
                    // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                    if (arcitem.Length > 0 && dEndRampingLengthSum < m_RampingEndInfo.length) {
                        arcitem.No = no++;
                        arcitem.MadebyRCC = true;
                        destDrawObjects.Add(arcitem);
                        dEndRampingLengthSum += arcitem.Length;
                        dRampingResidueLength = m_RampingEndInfo.Intervallength - arcitem.Length;
                    }
                }

                // 첫번째 item 입력 완료
                // 2번째 이후가 있다면 아래 실행.

                for (int i = rampingendbeginindex + 1; i < srcDrawObjects.Count; i++) {
                    if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                        dRampingResidueLength = 0;
                        break;
                    }
                    obj = srcDrawObjects[i];

                    if (obj is Line) {
                        UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                        UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                        Canvas.Line lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);

                        if (dRampingResidueLength > 0) {
                            // 전회차에 남은 거리를 object 로 만들어줬다면 모자란 만큼을 처음 object 로 만들어준다.

                            if (lineitem.Distance < dRampingResidueLength) {
                                // 다음 object 가 모자란 양을 다 못채우는 경우. 즉, 길이가 더 짧은 경우임. (사실상 ramping interval 이 더 짧아서 이런경우는 없을듯)
                                dRampingResidueLength -= lineitem.Distance;
                                lineitem.No = no++;
                                lineitem.MadebyRCC = true;
                                destDrawObjects.Add(lineitem);
                                dEndRampingLengthSum += lineitem.Distance;
                                continue;
                            } else {
                                lineitem.Distance = dRampingResidueLength;
                                dRampingResidueLength = 0;
                                lineitem.No = no++;
                                lineitem.MadebyRCC = true;
                                destDrawObjects.Add(lineitem);
                                dEndRampingLengthSum += lineitem.Distance;
                                dStartPoint = new UnitPoint(lineitem.PF2);

                                if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                                    // 구간길이를 모두 채우면 다음 object 이어 붙이고 종료
                                    lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue);
                                    // Ramping Object 아님
                                    lineitem.No = no++;
                                    lineitem.MadebyRCC = true;
                                    destDrawObjects.Add(lineitem);
                                    dRampingResidueLength = 0;
                                    break;
                                }
                            }
                        }

                        lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.
                                                                                                           // 중간지점 interval 길이만큼 반복으로 채워준다.
                        while (lineitem.Distance > m_RampingEndInfo.Intervallength) {
                            lineitem.Distance = m_RampingEndInfo.Intervallength;
                            dRampingResidueLength = 0;
                            lineitem.No = no++;
                            lineitem.MadebyRCC = true;
                            destDrawObjects.Add(lineitem);
                            dEndRampingLengthSum += lineitem.Distance;
                            dStartPoint = new UnitPoint(lineitem.PF2);
                            lineitem = new Canvas.Line(dStartPoint, dEndPoint, fLineDefualtWidth, Color.Blue); // while 돌리기 전에 비교를 위해서 라인을 먼저 만든다.

                            if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                                // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                                dRampingResidueLength = 0;
                                break;
                            }
                        }

                        // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                        lineitem.No = no++;
                        lineitem.MadebyRCC = true;
                        destDrawObjects.Add(lineitem);
                        dEndRampingLengthSum += lineitem.Distance;

                        if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            break;
                        } else {
                            // 여기까지오면 interval 보다 짧은 구간만 남는다. 채워넣어주고 모자란 길이를 residue 로 기록하자.
                            dRampingResidueLength = m_RampingEndInfo.Intervallength - lineitem.Distance;
                        }

                    } else if (obj is Arc) {
                        UnitPoint dStartPoint = new UnitPoint(obj.PF1);
                        UnitPoint dEndPoint = new UnitPoint(obj.PF2);

                        Canvas.Arc arcitem = (Canvas.Arc)obj.Clone();

                        if (dRampingResidueLength > 0) {
                            // 전회차에 남은 거리를 object 로 만들어줬다면 모자란 만큼을 처음 object 로 만들어준다.

                            if (arcitem.Length < dRampingResidueLength) {
                                // 다음 object 가 모자란 양을 다 못채우는 경우. 즉, 길이가 더 짧은 경우임. (사실상 ramping interval 이 더 짧아서 이런경우는 없을듯)
                                dRampingResidueLength -= arcitem.Length;
                                arcitem.No = no++;
                                arcitem.MadebyRCC = true;
                                destDrawObjects.Add(arcitem);
                                dEndRampingLengthSum += arcitem.Length;
                                continue;
                            } else {
                                arcitem.Length = (float)dRampingResidueLength;
                                dRampingResidueLength = 0;
                                arcitem.No = no++;
                                arcitem.MadebyRCC = true;
                                destDrawObjects.Add(arcitem);
                                dEndRampingLengthSum += (double)(arcitem.Length);
                                dStartPoint = new UnitPoint(arcitem.PF2);

                                if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                                    // 구간길이를 모두 채우면 다음 object 이어 붙이고 종료
                                    arcitem = (Canvas.Arc)obj.Clone();
                                    arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                                    arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);
                                    arcitem.No = no++;
                                    arcitem.MadebyRCC = true;
                                    destDrawObjects.Add(arcitem);
                                    dRampingResidueLength = 0;
                                    break;
                                }
                            }
                        }

                        arcitem = (Canvas.Arc)obj.Clone();
                        arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                        arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);

                        // 중간지점 interval 길이만큼 반복으로 채워준다.
                        while (arcitem.Length > m_RampingEndInfo.Intervallength) {
                            arcitem.Length = (float)m_RampingEndInfo.Intervallength;
                            dRampingResidueLength = 0;
                            arcitem.No = no++;
                            arcitem.MadebyRCC = true;
                            destDrawObjects.Add(arcitem);
                            dEndRampingLengthSum += arcitem.Length;
                            dStartPoint = new UnitPoint(arcitem.PF2);
                            arcitem = (Canvas.Arc)obj.Clone();
                            arcitem.PF1 = new PointF((float)dStartPoint.X, (float)dStartPoint.Y);
                            arcitem.PF2 = new PointF((float)dEndPoint.X, (float)dEndPoint.Y);

                            if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                                // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                                dRampingResidueLength = 0;
                                break;
                            }
                        }

                        if (dEndRampingLengthSum < m_RampingEndInfo.length) {
                            // 마지막 남은 잔여 길이 넣음. 위에 while 문에서 경로 생성이 끝났다면 남은 구간 전체를 넣고 종료. 생성이 안끝났어도 남은 구간을 다 넣고 다음 경로로 이동. 남은양을 전달한다.
                            arcitem.No = no++;
                            arcitem.MadebyRCC = true;
                            destDrawObjects.Add(arcitem);
                            dEndRampingLengthSum += arcitem.Length;
                        }

                        if (dEndRampingLengthSum >= m_RampingEndInfo.length) {
                            // 구간길이를 모두 채우면 다음 index 기록하고 ramping 생성 종료
                            dRampingResidueLength = 0;
                            break;
                        } else {
                            // 여기까지오면 interval 보다 짧은 구간만 남는다. 채워넣어주고 모자란 길이를 residue 로 기록하자.
                            dRampingResidueLength = m_RampingEndInfo.Intervallength - arcitem.Length;
                        }
                    } else {
                        // 없음
                    }
                }
            }

            // ramping power 를 설정해준다.
            dStartRampingLengthSum = 0;
            dEndRampingLengthSum = 0;

            // ramping start 구간 power 설정
            //
            for (int i = 0; i < destDrawObjects.Count; i++) {
                var obj = destDrawObjects[i];
                if (dStartRampingLengthSum >= m_RampingStartInfo.length) {
                    if (obj is Line) {
                        Line line = (Line)obj;
                        line.RCC_PowerRatio = 1;
                    }
                    if (obj is Arc) {
                        Arc arc = (Arc)obj;
                        arc.RCC_PowerRatio = 1;
                    }
                } else {
                    float powerratio = (float)((1 - m_RampingStartInfo.PowerRatioCh1) * dStartRampingLengthSum / m_RampingStartInfo.length + m_RampingStartInfo.PowerRatioCh1);
                    // 상한, 하한 설정 (ratio 는 0보다 크거나 같고 1보다 작거나 같다)
                    if (powerratio < 0) { powerratio = 0; } else if (powerratio > 1) { powerratio = 1; }
                    if (obj is Line) {
                        Line line = (Line)obj;
                        dStartRampingLengthSum += line.Distance;
                        line.RCC_PowerRatio = powerratio;
                    }
                    if (obj is Arc) {
                        Arc arc = (Arc)obj;
                        dStartRampingLengthSum += arc.Length;
                        arc.RCC_PowerRatio = powerratio;
                    }
                }
            }

            // ramping end 구간 power 설정
            //
            for (int i = destDrawObjects.Count - 1; i > 0; i--) {
                if (dEndRampingLengthSum > m_RampingEndInfo.length) {
                    break;
                }
                var obj = destDrawObjects[i];

                float powerratio = (float)((1 - m_RampingEndInfo.PowerRatioCh1) * dEndRampingLengthSum / m_RampingEndInfo.length + m_RampingEndInfo.PowerRatioCh1);
                // 상한, 하한 설정 (ratio 는 0보다 크거나 같고 1보다 작거나 같다)
                if (powerratio < 0) { powerratio = 0; } else if (powerratio > 1) { powerratio = 1; }

                if (obj is Line) {
                    Line line = (Line)obj;
                    dEndRampingLengthSum += line.Distance;
                    line.RCC_PowerRatio = powerratio;
                }
                if (obj is Arc) {
                    Arc arc = (Arc)obj;
                    dEndRampingLengthSum += arc.Length;
                    arc.RCC_PowerRatio = powerratio;
                }
            }
        }

        public bool CheckInterlockDrawingObjectPosition(List<IDrawObject> lsDrawObjects)
        {
            Func<double, double, double> GetDistance = (x, y) => Math.Sqrt(x * x + y * y);
            //Func<double, double, double, double, double> GetDistance = (x,y, centerx, centery) => Math.Sqrt(Math.Pow((x-centerx),2) + Math.Pow((y - centery), 2));
            Func<double, double, double, bool> CheckInRangeMinMax = (x, min, max) => {
                if (x < max && x > min) return true;
                else return false;
            };
            Func<double, double, bool> CheckInRange = (x, range) => {
                if (x < range && x > -range) return true;
                else return false;
            };
            bool bRet = true;
            dPathLengthSum = 0;
            foreach (var item in lsDrawObjects) {
                if (item is Line) {
                    var line = (Line)item;
                    dPathLengthSum += line.Distance;
                    if (!CheckInRange(GetDistance(line.P1.X - DetectedContourCenter.X, line.P1.Y - DetectedContourCenter.Y) - m_OriginArc.Radius, dInterlockDistRange)) {
                        Log.E($"[RCCCheckInterlock] Distance interlock Range Over, Distance(LinePF1, Center) - Distance(ArcRadius) : {GetDistance(line.P1.X - DetectedContourCenter.X, line.P1.Y - DetectedContourCenter.Y) - m_OriginArc.Radius} mm");
                        bRet = false;
                    }
                    if (!CheckInRange(GetDistance(line.P2.X - DetectedContourCenter.X, line.P2.Y - DetectedContourCenter.Y) - m_OriginArc.Radius, dInterlockDistRange)) {
                        Log.E($"[RCCCheckInterlock] Distance interlock Range Over, Distance(LinePF2, Center) - Distance(ArcRadius) : {GetDistance(line.P2.X - DetectedContourCenter.X, line.P2.Y - DetectedContourCenter.Y) - m_OriginArc.Radius} mm");
                        bRet = false;
                    }
                } else if (item is Arc) {
                    var arc = (Arc)item;
                    dPathLengthSum += arc.Length;
                    if (!CheckInRange(GetDistance(arc.PF1.X - DetectedContourCenter.X, arc.PF1.Y - DetectedContourCenter.Y) - m_OriginArc.Radius, dInterlockDistRange)) {
                        Log.E($"[RCCCheckInterlock] Distance interlock Range Over, Distance(ArcPF1, Center) - Distance(ArcRadius) : {GetDistance(arc.PF1.X - DetectedContourCenter.X, arc.PF1.Y - DetectedContourCenter.Y) - m_OriginArc.Radius} mm");
                        bRet = false;
                    }
                    if (!CheckInRange(GetDistance(arc.PF2.X - DetectedContourCenter.X, arc.PF2.Y - DetectedContourCenter.Y) - m_OriginArc.Radius, dInterlockDistRange)) {
                        Log.E($"[RCCCheckInterlock] Distance interlock Range Over, Distance(ArcPF2, Center) - Distance(ArcRadius) : {GetDistance(arc.PF2.X - DetectedContourCenter.X, arc.PF2.Y - DetectedContourCenter.Y) - m_OriginArc.Radius} mm");
                        bRet = false;
                    }
                    if (arc.Length > dInterlockArcLength) {
                        Log.E($"[RCCCheckInterlock] Distance interlock Range Over, ArcLength : {arc.Length} mm");
                        bRet = false;
                    }
                } else {

                }
            }
            if (!CheckInRange(dPathLengthSum - m_OriginArc.Length, dInterlockLengthDiffRange)) {
                Log.E($"[RCCCheckInterlock] Distance interlock Range Over, TotalPathLength - OriginArcLength : {dPathLengthSum - m_OriginArc.Length} mm");
                bRet = false;
            }
            if (!CheckInRange(m_OriginArc.Center.X - DetectedContourCenter.X, dInterlockCenterXYDiffRange)) {
                Log.E($"[RCCCheckInterlock] Distance interlock Range Over, OriginArcCenterX - DetectEdgeCenterX : {(m_OriginArc.Center.X - DetectedContourCenter.X).ToString("F2")} mm");
                bRet = false;
            }
            if (!CheckInRange(m_OriginArc.Center.Y - DetectedContourCenter.Y, dInterlockCenterXYDiffRange)) {
                Log.E($"[RCCCheckInterlock] Distance interlock Range Over, OriginArcCenterY - DetectEdgeCenterY : {(m_OriginArc.Center.Y - DetectedContourCenter.Y).ToString("F2")} mm");
                bRet = false;
            }
            return bRet;
        }

        public bool SaveDrawingObjectsToCSV(List<IDrawObject> lsDrawObjects, string strMode)
        {
            System.Data.DataTable dataTable = new System.Data.DataTable();

            string[] StrColumnTitles = {"No", "Line_P1X","Line_P1Y","Line_P2X","Line_P2Y","Arc_P1X","Arc_P1Y","Arc_P2X","Arc_P2Y",
                "Arc_CenterX","Arc_CenterY","Arc_StartAngle","Arc_EndAngle","Arc_SweepAngle", "Length", "PowerRatio"};

            dataTable.Columns.Add(new System.Data.DataColumn("Index", typeof(int)));

            foreach (var item in StrColumnTitles) {
                if (item == "No")
                    dataTable.Columns.Add(new System.Data.DataColumn(item, typeof(int)));
                else
                    dataTable.Columns.Add(new System.Data.DataColumn(item, typeof(double)));
            }

            //dataTable.Columns.Add(new System.Data.DataColumn("No.", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Line_P1X", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Line_P1Y", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Line_P2X", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Line_P2Y", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_P1X", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_P1Y", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_P2X", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_P2Y", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_CenterX", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_CenterY", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_StartAngle", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_EndAngle", typeof(int)));
            //dataTable.Columns.Add(new System.Data.DataColumn("Arc_SweepAngle", typeof(int)));

            for (int i = 0; i < lsDrawObjects.Count; i++) {
                System.Data.DataRow row = dataTable.NewRow();
                int iRowCount = dataTable.Rows.Count;
                object[] rowArray = new object[StrColumnTitles.Length + 1];
                for (int j = 0; j < rowArray.Length; j++)
                    rowArray[j] = 0;

                rowArray[0] = iRowCount + 1;
                //rowArray[1] = lsDrawObjects[i].No;

                if (lsDrawObjects[i] is Line) {
                    Line line = lsDrawObjects[i] as Line;
                    rowArray[1] = line.No + 1;
                    rowArray[2] = Math.Round(line.P1.X, 4);
                    rowArray[3] = Math.Round(line.P1.Y, 4);
                    rowArray[4] = Math.Round(line.P2.X, 4);
                    rowArray[5] = Math.Round(line.P2.Y, 4);
                    rowArray[15] = Math.Round(line.Distance, 4);
                    rowArray[16] = Math.Round(line.RCC_PowerRatio, 4);
                } else if (lsDrawObjects[i] is Arc) {
                    Arc arc = lsDrawObjects[i] as Arc;
                    rowArray[1] = arc.No + 1;
                    rowArray[6] = Math.Round(arc.PF1.X, 4);
                    rowArray[7] = Math.Round(arc.PF1.Y, 4);
                    rowArray[8] = Math.Round(arc.PF2.X, 4);
                    rowArray[9] = Math.Round(arc.PF2.Y, 4);
                    rowArray[10] = Math.Round(arc.Center.X, 4);
                    rowArray[11] = Math.Round(arc.Center.Y, 4);
                    rowArray[12] = Math.Round(arc.StartAngle, 4);
                    rowArray[13] = Math.Round(arc.EndAngle, 4);
                    rowArray[14] = Math.Round(arc.SweepAngle, 4);
                    rowArray[15] = Math.Round(arc.Length, 4);
                    rowArray[16] = Math.Round(arc.RCC_PowerRatio, 4);
                }
                row.ItemArray = rowArray;
                dataTable.Rows.Add(row);
            }

            //ILSOSConfig로 파일 경로 수정
            var DefaultPath = ConfigurationManager.AppSettings.Get("DATA_PATH");
            string fullPath = Path.Combine(DefaultPath, "_device", "_drawobject", "DrawObject");
            string fileName = fullPath + string.Format("\\{0}_{1}.csv", strMode, DateTime.Now.ToString("yyyyMMdd_HHmmss.fff"));

            ExcelManagementUnit.ExportToCSV(fileName, dataTable,",",false);

            return true;
        }

        public void MergePolygonSample(double dMergeDist)
        {
            //Pixel의 시작위치를 Merge전에 첫 Pixel은 가지고있어야 시작점 위치가 변경되지 않을듯 하다
            // Arc 정보가없으면 그냥 default 생성된 rearranged_polygon list 를 사용
            if (m_OriginArc == null)
                return;

            // 본래 고객이 그린 Arc 방향에 따라서 point array 방향을 돌려준다. rearrange 한 후에 돌려주는게 계산량이 적을듯.
            // Find Edge 로 찾은 방향은 FindContour 방향과 반대로 되어 있어서 수정함.
            //if (m_OriginArc.Direction == Arc.eDirection.CW)
            if (m_OriginArc.Direction == Arc.eDirection.CCW)
                polygon.Reverse();

            // 시작위치를 찾아서 순서 보정. 좌표계 pixel 좌표계 주의.
            double startX, startY;
            CalAnglePoint(DetectedContourCenter.X, DetectedContourCenter.Y, m_OriginArc.Radius, m_OriginArc.StartAngle, out startX, out startY);
            ConvertPixelAxisFromDrawingObjectAxis(new UnitPoint(startX, startY), out startX, out startY);
            List<double> DistancelistFromStartPoint = new List<double>();
            for (int i = 0; i < polygon.Count; i++) {
                DistancelistFromStartPoint.Add(Math.Sqrt(Math.Pow(Convert.ToDouble(polygon[i].x) - startX, 2) + Math.Pow(Convert.ToDouble(polygon[i].y) - startY, 2)));
            }
            // 리스트에서 가장 작은 값 찾기
            double minValueFromStartPoint = DistancelistFromStartPoint.Min();
            // 가장 작은 값의 인덱스 찾기
            int minIndexFromStartPoint = DistancelistFromStartPoint.IndexOf(minValueFromStartPoint);
            // 처음부터 minIndex개의 아이템을 잘라내기
            TPolygon firstpolygons = polygon.GetRange(0, minIndexFromStartPoint + 1);

            // 원래 리스트에서 첫 minIndex개의 아이템 제거
            polygon.RemoveRange(0, minIndexFromStartPoint + 1);

            // 잘라낸 minIndex개의 아이템을 뒤에 붙임
            polygon.AddRange(firstpolygons);

            if (m_OriginArc.AbsSweepAngle > 360) {
                // 종료위치를 찾아서 순서 보정. 좌표계 pixel 좌표계 주의.
                double endX, endY;
                CalAnglePoint(DetectedContourCenter.X, DetectedContourCenter.Y, m_OriginArc.Radius, m_OriginArc.EndAngle, out endX, out endY);
                ConvertPixelAxisFromDrawingObjectAxis(new UnitPoint(endX, endY), out endX, out endY);
                List<double> DistancelistFromEndPoint = new List<double>();
                for (int i = 0; i < polygon.Count; i++) {
                    DistancelistFromEndPoint.Add(Math.Sqrt(Math.Pow(Convert.ToDouble(polygon[i].x) - endX, 2) + Math.Pow(Convert.ToDouble(polygon[i].y) - endY, 2)));
                }
                // 리스트에서 가장 작은 값 찾기
                double minValueFromEndPoint = DistancelistFromEndPoint.Min();
                // 가장 작은 값의 인덱스 찾기
                int minIndexFromEndPoint = DistancelistFromEndPoint.IndexOf(minValueFromEndPoint);
                end_point_index = polygon.Count;
                // 처음부터 minIndex개의 아이템을 복사하기
                TPolygon addpolygons = polygon.GetRange(0, minIndexFromEndPoint + 1);
                // 복사한 minIndex개의 아이템을 뒤에 붙임
                polygon.AddRange(addpolygons);
            } else if (m_OriginArc.AbsSweepAngle < 360) {
                // sweep angle 이 360보다 작은 경우 end 까지만 사용하고 나머지는 버린다.

                // 종료위치를 찾아서 순서 보정. 좌표계 pixel 좌표계 주의.
                double endX, endY;
                CalAnglePoint(DetectedContourCenter.X, DetectedContourCenter.Y, m_OriginArc.Radius, m_OriginArc.EndAngle, out endX, out endY);
                ConvertPixelAxisFromDrawingObjectAxis(new UnitPoint(endX, endY), out endX, out endY);

                List<double> DistancelistFromEndPoint = new List<double>();
                for (int i = 0; i < polygon.Count; i++) {
                    DistancelistFromEndPoint.Add(Math.Sqrt(Math.Pow(Convert.ToDouble(polygon[i].x) - endX, 2) + Math.Pow(Convert.ToDouble(polygon[i].y) - endY, 2)));
                }
                // 리스트에서 가장 작은 값 찾기
                double minValueFromEndPoint = DistancelistFromEndPoint.Min();
                // 가장 작은 값의 인덱스 찾기
                int minIndexFromEndPoint = DistancelistFromEndPoint.IndexOf(minValueFromEndPoint);

                // 원래 리스트에서 마지막 minIndex개의 아이템 제거
                polygon.RemoveRange(minIndexFromEndPoint, polygon.Count - minIndexFromEndPoint);
            } else {
                // 360도 일때는 시작 point 를 end point 에 하나 더 붙여줘야 원이 완성된다
                polygon.Add(polygon[0]);
            }

            patheditor.MergePoints(polygon, out merged_polygon, dMergeDist);
        }
        //public void MergePolygonSample(out TPolygon ptPolygon)
        //{
        //    MergePolygonSample();
        //    ptPolygon = merged_polygon;
        //}
        public void ReArrangePoints()
        {
            patheditor.RearrangePoints(merged_polygon, out rearranged_polygon);
        }

        private void CalAnglePoint(double cx, double cy, double radius, double degree, out double px, out double py)
        {
            double radian = degree * Math.PI / 180;
            px = cx + radius * Math.Cos(radian);
            py = cy + radius * Math.Sin(radian);
        }
        public void ConvertMILToMat(MIL_ID MILImage, out Mat convMatImage)
        {
            //WPF Bitmapsource로 변환
            int width = (int)MIL.MbufInquire(MILImage, MIL.M_SIZE_X, MIL.M_NULL);
            int height = (int)MIL.MbufInquire(MILImage, MIL.M_SIZE_Y, MIL.M_NULL);
            //int stride = width; // Assuming 8-bit grayscale image
            int stride = width * 3; // Assuming 24-bit BRG image
            byte[] imageData = new byte[width * height * 3];
            //MIL.MbufGet(MILImage, imageData); // 8-bit일 경우 사용
            MIL.MbufGetColor(MILImage, MIL.M_PACKED + MIL.M_BGR24, MIL.M_ALL_BANDS, imageData);

            //8-bit 1ch gray일 경우 사용
            //BitmapSource bitmapSource = BitmapSource.Create(
            //    width, height, 96, 96, System.Windows.Media.PixelFormats.Gray8, null, imageData, stride);

            //32-bit 3ch bgr
            BitmapSource bitmapSource = BitmapSource.Create(
                width, height, 96, 96, System.Windows.Media.PixelFormats.Bgr24, null, imageData, stride);

            //Convert bitmapsource to Mat
            convMatImage = bitmapSource.ToMat();

            // MIL 해제
            MIL.MbufFree(MILImage);
        }
        public Point[][] FindMaxContour_old(Mat oriImg, double threshold, int morpIterations, int morpMarkSize)
        {
            // Convert to grayscale
            Mat grayImg = new Mat();
            Cv2.CvtColor(oriImg, grayImg, ColorConversionCodes.BGR2GRAY);

            // Apply threshold
            Mat thresImg = new Mat();
            Cv2.Threshold(grayImg, thresImg, threshold, 200, ThresholdTypes.Binary);

            // Find contours
            Point[][] contours;
            HierarchyIndex[] hierarchy;
            Cv2.FindContours(thresImg, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);

            // Find the largest contour
            double maxArea = 0;
            int maxCntNo = 0;
            for (int i = 0; i < contours.Length; i++) {
                double area = Cv2.ContourArea(contours[i]);
                if (maxArea < area) {
                    maxArea = area;
                    maxCntNo = i;
                }
            }
            // Draw the largest contour
            Mat maxCntImg = new Mat(oriImg.Rows, oriImg.Cols, MatType.CV_8UC1, Scalar.Black);
            Cv2.DrawContours(maxCntImg, contours, maxCntNo, Scalar.White, -1);

            // Apply morphological operations
            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(morpMarkSize, morpMarkSize));
            Cv2.MorphologyEx(maxCntImg, maxCntImg, MorphTypes.Erode, kernel, iterations: morpIterations);

            // Find contours again on the eroded image
            Point[][] erodeContours;
            Cv2.FindContours(maxCntImg, out erodeContours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);

            return erodeContours;
        }

        //RCC용 MaxContour 알고리즘으로 변경
        public Point[][] FindMaxContour(Mat oriImg, double threshold, int morpIterations, int morpMarkSize)
        {
            // Convert to grayscale
            Mat grayImg = new Mat();
            Cv2.CvtColor(oriImg, grayImg, ColorConversionCodes.BGR2GRAY);

            //// Apply Sobel filter
            //Mat sobelx = new Mat();
            //Mat sobely = new Mat();
            //Cv2.Sobel(grayImg, sobelx, MatType.CV_64F, 1, 0, 3);
            //Cv2.Sobel(grayImg, sobely, MatType.CV_64F, 0, 1, 3);

            //// Convert scale to absolute
            //Cv2.ConvertScaleAbs(sobelx, sobelx);
            //Cv2.ConvertScaleAbs(sobely, sobely);

            //// Combine Sobel results
            //Mat sobelCombined = new Mat();
            //Cv2.AddWeighted(sobelx, 0.5, sobely, 0.5, 0, sobelCombined);


            // Apply threshold
            Mat thresImg = new Mat();
            Cv2.Threshold(grayImg, thresImg, threshold, 200, ThresholdTypes.Binary);

            // Find contours
            Point[][] contours;
            HierarchyIndex[] hierarchy;
            Cv2.FindContours(thresImg, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);

            // Find the largest contour
            double maxArea = 0;
            int maxCntNo = 0;
            for (int i = 0; i < contours.Length; i++) {
                double area = Cv2.ContourArea(contours[i]);
                if (maxArea < area) {
                    maxArea = area;
                    maxCntNo = i;
                }
            }
            // Draw the largest contour
            Mat maxCntImg = new Mat(oriImg.Rows, oriImg.Cols, MatType.CV_8UC1, Scalar.Black);
            Cv2.DrawContours(maxCntImg, contours, maxCntNo, Scalar.White, -1);

            // Apply morphological operations
            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(morpMarkSize, morpMarkSize));
            Cv2.MorphologyEx(maxCntImg, maxCntImg, MorphTypes.Erode, kernel, iterations: morpIterations);

            // Find contours again on the eroded image
            Point[][] erodeContours;
            Cv2.FindContours(maxCntImg, out erodeContours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);

            Point2f center;
            float radius;
            Point[] p = erodeContours[0];
            Cv2.MinEnclosingCircle(p, out center, out radius);
            ConvertDrawingObjectAxis(center.X, center.Y, out DetectedContourCenter);
            ConvertDrawingObjectAxis(radius, out fDetectedContourRadius);

            return erodeContours;
        }
        public Point2f CalculateCentroid(Point[] contour)
        {
            Moments moments = Cv2.Moments(contour);
            return new Point2f((float)(moments.M10 / moments.M00), (float)(moments.M01 / moments.M00));
        }
        public Point[][] ShrinkPixelContour(Point[] contour, int shrinkBy)
        {
            List<Point> shrunkContour = new List<Point>();
            Point2f centroid = CalculateCentroid(contour);
            foreach (var point in contour) {
                Point2f point2f = new Point2f(point.X, point.Y); // Convert Point to Point2f
                Point2f direction = point2f - centroid;
                Mat directionMat = new Mat(1, 2, MatType.CV_32F);
                directionMat.Set<float>(0, 0, direction.X);
                directionMat.Set<float>(0, 1, direction.Y);
                float length = (float)Cv2.Norm(directionMat);
                float shrinkRatio = (length - shrinkBy) / length;
                Point2f newPoint = centroid + direction * shrinkRatio;
                shrunkContour.Add(new Point((int)newPoint.X, (int)newPoint.Y)); // Convert Point2f back to Point
            }
            return new Point[][] { shrunkContour.ToArray() }; // Wrap in a 2D array
        }

        public Point[][] ShrinkPixelContourCSV(Point[] contour, double[] theta_list, double[] offset_list)
        {
            List<Point> shrunkContour = new List<Point>();
            Point2f centroid = CalculateCentroid(contour);
            int cnt = 0;
            foreach (var point in contour) {
                Point2f point2f = new Point2f(point.X, point.Y); // Convert Point to Point2f
                Point2f direction = point2f - centroid;
                Mat directionMat = new Mat(1, 2, MatType.CV_32F);
                directionMat.Set<float>(0, 0, direction.X);
                directionMat.Set<float>(0, 1, direction.Y);

                // 각 사분면마다 다르게 angle 계산 (오른쪽부터 시계방향으로 0~360도가 되도록 통일)
                float angle = 0;
                if (direction.X > 0 && direction.Y >= 0) //제 4사분면
                    angle = (float)Math.Atan2(direction.Y, direction.X);
                else if (direction.X <= 0 && direction.Y > 0) //제 3사분면
                    angle = (float)(Math.Atan2(-direction.X, direction.Y) + Math.PI / 2);
                else if (direction.X <= 0 && direction.Y < 0)//제 2사분면
                    angle = (float)(Math.Atan2(-direction.Y, -direction.X) + Math.PI);
                else
                    angle = (float)(Math.Atan2(direction.X, -direction.Y) + Math.PI * 3 / 2); //제 1사분면
                float angleInDegrees = angle * (180f / (float)Math.PI);

                while (cnt < contour.Length - 1) {
                    if (Math.Abs(theta_list[cnt] - angleInDegrees) < Math.Abs(theta_list[cnt + 1] - angleInDegrees))
                        break;
                    cnt += 1;
                }


                float length = (float)Cv2.Norm(directionMat);
                float shrinkRatio = (length - (float)offset_list[cnt]) / length;
                Point2f newPoint = centroid + direction * shrinkRatio;
                shrunkContour.Add(new Point((int)newPoint.X, (int)newPoint.Y));
            }
            return new Point[][] { shrunkContour.ToArray() };
        }

        public Point[][] ShrinkPixelContourQuad(Point[] contour, int shrinkPixel1, int shrinkPixel2, int shrinkPixel3, int shrinkPixel4, Func<float, int, int, int, int, int> shrinkByFunc)
        {
            List<Point> shrunkContour = new List<Point>();
            Point2f centroid = CalculateCentroid(contour);
            //Contour를 특정각도로 나누어서 shrinkRatio를 바꿔보자 우선 하드코딩으로

            foreach (var point in contour) {
                Point2f point2f = new Point2f(point.X, point.Y); // Convert Point to Point2f
                Point2f direction = point2f - centroid;
                Mat directionMat = new Mat(1, 2, MatType.CV_32F);
                directionMat.Set<float>(0, 0, direction.X);
                directionMat.Set<float>(0, 1, direction.Y);

                // Atan2는 0도 기준으로 아래쪽 방향이 +라서 각도에 -를 붙여줌
                float angle = -(float)Math.Atan2(direction.Y, direction.X);

                float angleInDegrees = angle * (180f / (float)Math.PI);

                int shrinkBy = shrinkByFunc(angleInDegrees, shrinkPixel1, shrinkPixel2, shrinkPixel3, shrinkPixel4);

                float length = (float)Cv2.Norm(directionMat);
                float shrinkRatio = (length - shrinkBy) / length;
                Point2f newPoint = centroid + direction * shrinkRatio;
                shrunkContour.Add(new Point((int)newPoint.X, (int)newPoint.Y));
            }
            return new Point[][] { shrunkContour.ToArray() };
        }
        public int ShrinkByFunction(float angle, int shrinkPixel1, int shrinkPixel2, int shrinkPixel3, int shrinkPixel4)
        {
            if (angle >= 0 && angle < 90)
                return shrinkPixel1;
            else if (angle >= 90 && angle < 180)
                return shrinkPixel2;
            else if (angle >= -180 && angle < -90)
                return shrinkPixel3;
            else
                return shrinkPixel4;
        }
        public Point[][] FindMaxContour(Mat oriImg, double threshold, int shrinkPixel)
        {
            // Convert to grayscale
            Mat grayImg = new Mat();
            Cv2.CvtColor(oriImg, grayImg, ColorConversionCodes.BGR2GRAY);
            // Threshold
            Mat thresImg = new Mat();
            Cv2.Threshold(grayImg, thresImg, threshold, 200, ThresholdTypes.Binary);
            // Find contours (1st)
            Point[][] contours;
            HierarchyIndex[] hierarchy;
            Cv2.FindContours(thresImg, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
            // Find max contour
            Point[] maxCnt = contours.OrderByDescending(c => Cv2.ContourArea(c)).First();
            // Shrink max contour
            Point[][] shrunkCnt = ShrinkPixelContour(maxCnt, shrinkPixel);
            return shrunkCnt;
        }

        public Point[][] ReSizeFindMaxContour(Mat oriImg, double scale, double threshold, int shrinkPixel)
        {
            // Convert to grayscale
            Mat grayImg = new Mat();
            Cv2.CvtColor(oriImg, grayImg, ColorConversionCodes.BGR2GRAY);

            // Image Resize
            // Scale 다운 후 아래서 Contour에 scale을 다시 곱해줌
            double imgScale = 1.0 / scale;
            Mat reGrayImg = new Mat();
            Cv2.Resize(grayImg, reGrayImg, new Size(0, 0), imgScale, imgScale, InterpolationFlags.Linear);

            //// Apply Sobel filter
            //Mat sobelx = new Mat();
            //Mat sobely = new Mat();
            //Cv2.Sobel(reGrayImg, sobelx, MatType.CV_64F, 1, 0, 3);
            //Cv2.Sobel(reGrayImg, sobely, MatType.CV_64F, 0, 1, 3);

            //// Convert scale to absolute
            //Cv2.ConvertScaleAbs(sobelx, sobelx);
            //Cv2.ConvertScaleAbs(sobely, sobely);

            //// Combine Sobel results
            //Mat sobelCombined = new Mat();
            //Cv2.AddWeighted(sobelx, 0.5, sobely, 0.5, 0, sobelCombined);

            //Gaussian blur
            Mat blurredImg = new Mat();
            //Cv2.MedianBlur(reGrayImg, blurredImg, 5); // 5 is the kernel size, must be odd
            Cv2.GaussianBlur(reGrayImg, blurredImg, new Size(9, 9), 0);
            string filepath = Path.Combine(ConfigurationManager.AppSettings.Get("DATA_PATH"), "_vision", "Test",
                    string.Format($"{DateTime.Now.Year}_{DateTime.Now.Month}_{DateTime.Now.Day}/{DateTime.Now.ToString("HHmmss")}_BlurImg.PNG"));
            Cv2.ImWrite(filepath, blurredImg);
            //AddaptiveThresImg
            //Mat adaptiveThresImg = new Mat();
            //Cv2.AdaptiveThreshold(blurredImg, adaptiveThresImg, 255,
            //             AdaptiveThresholdTypes.GaussianC,
            //             ThresholdTypes.Binary, blockSize, constant);

            // Apply Bilateral Filter to preserve edges while reducing noise
            Mat bilateralFilteredImg = new Mat();
            Cv2.BilateralFilter(blurredImg, bilateralFilteredImg, 9, 75, 75);

            // Threshold
            Mat thresImg = new Mat();
            Cv2.Threshold(bilateralFilteredImg, thresImg, threshold, 200, ThresholdTypes.Binary);

            filepath = Path.Combine(ConfigurationManager.AppSettings.Get("DATA_PATH"), "_vision", "Test",
                    string.Format($"{DateTime.Now.Year}_{DateTime.Now.Month}_{DateTime.Now.Day}/{DateTime.Now.ToString("HHmmss")}_ThresImg.PNG"));
            Cv2.ImWrite(filepath, thresImg);

            // Apply morphological operations
            //Mat morpImg = new Mat();
            //Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new Size(morpMaskSize, morpMaskSize));
            //Cv2.MorphologyEx(thresImg, morpImg, MorphTypes.Erode, kernel);
            //filepath = Path.Combine(ConfigurationManager.AppSettings.Get("DATA_PATH"), "_vision", "Test",
            //        string.Format($"{DateTime.Now.Year}_{DateTime.Now.Month}_{DateTime.Now.Day}/{DateTime.Now.ToString("HHmmss")}_MorpImg.PNG"));
            //Cv2.ImWrite(filepath, morpImg);

            // Find contours (1st)
            Point[][] contours;
            HierarchyIndex[] hierarchy;
            Cv2.FindContours(thresImg, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
            // Find max contour
            Point[] maxCnt = contours.OrderByDescending(c => Cv2.ContourArea(c)).First();
            // Shrink max contour

            for (int i = 0; i < maxCnt.Length; i++) {
                maxCnt[i].X = (int)(maxCnt[i].X * scale);
                maxCnt[i].Y = (int)(maxCnt[i].Y * scale);
            }
            Point[][] shrunkCnt = ShrinkPixelContour(maxCnt, shrinkPixel);

            Point2f center;
            float radius;
            Point[] p = shrunkCnt[0];
            Cv2.MinEnclosingCircle(p, out center, out radius);
            ConvertDrawingObjectAxis(center.X, center.Y, out DetectedContourCenter);
            ConvertDrawingObjectAxis(radius, out fDetectedContourRadius);

            return shrunkCnt;

        }


        public Mat MaskingImage(Mat origImag, double dInnerCircleRadius, double dOuterCircleRadius)
        {
            // origImag : origin image
            // dCircleRadius : Mask 할 원의 반경. mm 단위로 받아서 pixel 전환해주자
            // bWhite : true 면 원안의 영역을 사용. false 면 원안의 영역을 미사용.
            // return value : mask 이후의 image.
            Mat retImg = new Mat();
            Mat MaskImg = new Mat(origImag.Size(), MatType.CV_8UC1, Scalar.All(0));
            int nInnerCircleRadius = Convert.ToInt32(dInnerCircleRadius / PixelResolution);
            int nOuterCircleCircleRadius = Convert.ToInt32(dOuterCircleRadius / PixelResolution);
            Cv2.Circle(MaskImg, new Point(origImag.Width / 2, origImag.Height / 2), nOuterCircleCircleRadius, Scalar.All(255), -1);
            Cv2.Circle(MaskImg, new Point(origImag.Width / 2, origImag.Height / 2), nInnerCircleRadius, Scalar.All(0), -1);
            Cv2.BitwiseAnd(origImag, origImag, retImg, MaskImg);
            return retImg;
        }
        public int ReplaceRCCObject(List<IDrawObject> sourcelist, List<IDrawObject> targetlist)
        {
            // sourcelist 의 item 중 RCC mode 가 true 인 것을 targetlist 로 대체.
            // targetlist 는 group 으로 묶어서 1개 object 로 인식하게 한다.
            // RCC Generated Object 를 생성한

            if (sourcelist == null || targetlist == null)
                return -1;

            // Group Object 를 만든다.
            Group group = new Group();

            // RCC Generated Object 를 생성한 Group 의 sublist 로 넣어준다. 참조가 아닌 깊은 복사로 하자.

            List<IDrawObject> tempobject = new List<IDrawObject>();
            int startindex = 0; int nCount = targetlist.Count;
            for (int i = startindex; i < targetlist.Count; i++) {
                if (i >= startindex + nCount)
                    break;
                tempobject.Add(targetlist[i]);
            }
            group.SubObjects = tempobject;

            // Recipe 에서 RCCArc True object 를 찾는다
            // RCCArc 를 Group 으로 Replace 한다.

            // iteration 은 읽기 전용이므로 foreach 말고 for 문을 써야한다.
            for (int i = 0; i < sourcelist.Count; i++) {
                IDrawObject obj = sourcelist[i] as IDrawObject;
                if (CheckReplaceRCCObject(group, obj) == true) {
                    // 부모를 넘겨줘야 item 이 replace 된다
                    ReplaceArcToRCCObjectGroup(group, sourcelist, i);
                } else {
                    UnitPoint offset = DetectedContourCenter - m_OriginArc.Center;
                    IDrawObject objclone = obj.Clone();
                    objclone.Move(offset);
                    sourcelist[i] = objclone;
                }
            }

            return 0;
        }
        public int ReplaceObject(List<IDrawObject> sourcelist, double offset_X, double offset_Y, double offset_t, UnitPoint inji_center)
        {
            if (sourcelist == null)
                return -1;
            offset_t = offset_t * (180 / Math.PI);
            // iteration 은 읽기 전용이므로 foreach 말고 for 문을 써야한다.
            for (int i = 0; i < sourcelist.Count; i++) {
                IDrawObject obj = sourcelist[i] as IDrawObject;

                UnitPoint offset = new UnitPoint(offset_X, -offset_Y);


                IDrawObject objclone = obj.Clone();
                objclone.Move(offset);
                //회전방향:반시계, 단위 : degree
                objclone.Rotate((float)offset_t, inji_center);

                sourcelist[i] = objclone;

            }

            return 0;
        }

        private static bool CheckReplaceRCCObject(Group SrcGroup, IDrawObject obj)
        {
            // CheckReplaceRCCObject 는 Group 에 대하여 Recursive call 한다.
            // group 안에 arc 가 있으면 check 만하는게 아니고 replace 까지 한다.

            if (obj.Enabled == true) {
                if (obj is Arc) {
                    if (((Arc)obj).RCCArc == true)
                        return true;
                } else if (obj is Group) {
                    CheckRCCGroupObject(SrcGroup, (Group)obj);
                    return false;
                } else
                    return false;
            }
            return false;
        }

        private static void CheckRCCGroupObject(Group SrcGroup, Group Targetobj)
        {
            // iteration 은 읽기 전용이므로 foreach 말고 for 문을 써야한다.
            for (int i = 0; i < Targetobj.SubObjects.Count; i++) {
                IDrawObject subObj = Targetobj.SubObjects[i] as IDrawObject;
                if (CheckReplaceRCCObject(SrcGroup, subObj) == true) {
                    // 부모와 index를 넘겨줘야 item 이 replace 된다
                    ReplaceArcToRCCObjectGroup(SrcGroup, Targetobj.SubObjects, i);
                    return;
                } else {
                    //UnitPoint offset = DetectedContourCenter - m_OriginArc.Center;
                    //subObj.Move(offset);
                }
            }
        }
        private static void ReplaceArcToRCCObjectGroup(Group SrcGroup, List<IDrawObject> parentlist, int index)
        {
            if (parentlist.Count == 0 || parentlist.Count < index)
                return;
            Arc obj = (Arc)parentlist[index];
            int paramNo = obj.ScannerParamNo;
            int paramID = obj.ScannerParamID;
            int itemNo = obj.No;
            //여기서 Clone시 parentlist에 powerratio가 1로 바뀜
            parentlist[index] = SrcGroup.Clone();
            parentlist[index].No = itemNo;

            foreach (IDrawObject objitem in ((Group)parentlist[index]).SubObjects) {
                if (objitem is Line)
                    ((Line)objitem).ScannerParamNo = paramNo;
                else if (objitem is Arc)
                    ((Arc)objitem).ScannerParamNo = paramNo;
                objitem.ScannerParamID = paramID;
            }
        }
        public void SetBaseArc(Arc arc)
        {
            // 이 함수는 한번만 호출해도 계속 사용할 수 있도록 하자. (참조로 덮어써지지 않도록 주의)
            // Generate Object 의 기본 정보를 제공하는 Arc Object 를 등록한다
            m_OriginArc = arc;
            bArcHasRamping = false;

            #region ramping 설정 추출. ramping 이 있을 경우에는 polygon sample 을 slpit 해야한다. 이 정보를 여기서 추출하고 generate 할때 사용한다.
            // Arc 받아온 것에서 Ramping 정보 및 출력 정보 추출
            ScannerParam param = ScannerCanvasUserCtrl.ScannerParams[m_OriginArc.ScannerParamNo];


            // LoadArc Code 참고함. scanner 에 넣어주는 부분만 list 로 저장해두고 ramping 구간 object 생성될때 power 를 적용한다.
            double radius = Math.Sqrt((m_OriginArc.CenterPointF.X - m_OriginArc.PF1.X) * (m_OriginArc.CenterPointF.X - m_OriginArc.PF1.X) + (m_OriginArc.CenterPointF.Y - m_OriginArc.PF1.Y) * (m_OriginArc.CenterPointF.Y - m_OriginArc.PF1.Y));
            double length = param.ArcRampingInterval; // ramping 1count 단위 길이. 보통 0.1mm 를 추천함. 현재는 Start 와 End 를 같이 쓰는듯.
            double theta = 0;

            // 이 함수에서 출력 비율에 대한 정의가 중요하다.
            // Ramping 의 비율 : ex) 50% 라고 한다면 원래 출력이 Laser source 의 10% 였다면 5% 가 레이저출력비율 (이것은 CalibrateWattToPercent 에서 설정되는 값일것이다.)
            //                  이 함수에서는 계산된 source 비율이 아니라 Ramping 의 비율만 정해주도록 하자 (50% 로 쓰겠다는 말임)
            //                  즉, Laser 가 2KW 짜리이고, parameter 에서 100W 설정하고 Ramping start 가 50% 이면 시작 출력은 2.5% 가 되지만, 이 함수에서는 50% 로 저장하겠다는 얘기임
            // LoadArcScannerParam 에서 MadebyRCC object 출력은 새로 만들어줘야하기 때문에 그 함수에서 laser 출력을 계산해서 스캐너에 넣겠음.


            // 0. Sweep 방향에 따른 회전 방향 설정
            if (m_OriginArc.Direction == Arc.eDirection.CCW) theta = (length / radius) * (180 / Math.PI);
            if (m_OriginArc.Direction == Arc.eDirection.CW) theta = (-length / radius) * (180 / Math.PI);

            if ((param.RampingStartDist > 0 || param.RampingEndDist > 0)
                && (param.RampingStartDist + param.RampingEndDist < radius * Math.Abs(m_OriginArc.SweepAngle))
                && !param.WobbelEnable && !param.SnowManEnable) {
                bArcHasRamping = true;
                // 1.1. 데이터테이블 기준으로 파워 동작
                //percentLaser1 = (float)_laserPowerCalParam.CalibrateWattToPercent(param.LaserPower1, (uint)eAnalogPortOut.DA1);

                // 1.2. Ramping을 위한 변수 설정
                m_RampingStartInfo.m_Count = (int)(param.RampingStartDist / length);
                m_RampingEndInfo.m_Count = (int)(param.RampingEndDist / length);

                m_RampingStartInfo.length = param.RampingStartDist;
                m_RampingEndInfo.length = param.RampingEndDist;

                // 2.1. Rising Edge 시작 파워 설정. 현재는 ring, center 구분이 없다. 기존에는 center 만 쓰게 되어있는데, 일단 둘다 적용해주자.
                m_RampingStartInfo.PowerRatioCh1 = (float)param.RampingStartPower / 100 <= 100 ?
                                            (float)param.RampingStartPower / 100 : 100;
                m_RampingStartInfo.PowerRatioCh2 = m_RampingStartInfo.PowerRatioCh1;    // parameter 구분이 없어서 덮어써준다. 나중에 확장하면 여기만 추가해주자.
                m_RampingStartInfo.Intervallength = length;

                m_RampingEndInfo.PowerRatioCh1 = (float)param.RampingEndPower / 100 <= 100 ?
                            (float)param.RampingEndPower / 100 : 100;
                m_RampingEndInfo.PowerRatioCh2 = m_RampingEndInfo.PowerRatioCh1;    // parameter 구분이 없어서 덮어써준다. 나중에 확장하면 여기만 추가해주자.
                m_RampingEndInfo.Intervallength = length;

                // interlock 처리
                // start ramping length + end ramping length 가 전체 길이보다 길면 안된다.
                if (m_OriginArc.Length < param.RampingStartDist + param.RampingEndDist)
                    bArcHasRamping = false;     // ramping 을 쓰지 않는다.
            }
            #endregion
        }

        public void FindCenterPoint(Mat srcImg, double diff_Threshold, out Point center_point)
        {
            // divide 는 각도를 쪼개는 갯수

            Mat grayImg = new Mat();
            Cv2.CvtColor(srcImg, grayImg, ColorConversionCodes.BGR2GRAY);
            int height = grayImg.Height;
            int width = grayImg.Width;

            // Right
            int p_x = width - 3;
            int p_y = height / 2;
            Point right = new Point(0, 0);

            while (p_x > (width / 2)) {
                p_x--;
                double outer = Convert.ToDouble(grayImg.At<byte>(p_y, p_x + 1) + grayImg.At<byte>(p_y, p_x + 2));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x + 1) + grayImg.At<byte>(p_y - 1, p_x + 2));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x + 1) + grayImg.At<byte>(p_y + 1, p_x + 2));

                double inner = Convert.ToDouble(grayImg.At<byte>(p_y, p_x - 2) + grayImg.At<byte>(p_y, p_x - 1));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x - 2) + grayImg.At<byte>(p_y - 1, p_x - 1));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x - 2) + grayImg.At<byte>(p_y + 1, p_x - 1));

                if ((inner - outer) / 6 > diff_Threshold) {
                    right = new Point(p_x, p_y);
                    break;
                }
            }

            // Left
            p_x = 2;
            p_y = height / 2;
            Point left = new Point(0, 0);

            while (p_x < (width / 2)) {
                p_x++;
                double outer = Convert.ToDouble(grayImg.At<byte>(p_y, p_x - 1) + grayImg.At<byte>(p_y, p_x - 2));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x - 1) + grayImg.At<byte>(p_y + 1, p_x - 2));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x - 1) + grayImg.At<byte>(p_y - 1, p_x - 2));

                double inner = Convert.ToDouble(grayImg.At<byte>(p_y, p_x + 2) + grayImg.At<byte>(p_y, p_x + 1));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x + 2) + grayImg.At<byte>(p_y + 1, p_x + 1));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x + 2) + grayImg.At<byte>(p_y - 1, p_x + 1));

                if ((inner - outer) / 6 > diff_Threshold) {
                    left = new Point(p_x, p_y);
                    break;
                }
            }

            // Top
            p_x = width / 2;
            p_y = 2;
            Point top = new Point(0, 0);

            while (p_y < (height / 2)) {
                p_y++;
                double outer = Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x) + grayImg.At<byte>(p_y - 2, p_x));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x + 1) + grayImg.At<byte>(p_y - 2, p_x + 1));
                outer += Convert.ToDouble(grayImg.At<byte>(p_y - 1, p_x - 1) + grayImg.At<byte>(p_y - 2, p_x - 1));

                double inner = Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x) + grayImg.At<byte>(p_y + 2, p_x));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x + 1) + grayImg.At<byte>(p_y + 2, p_x + 1));
                inner += Convert.ToDouble(grayImg.At<byte>(p_y + 1, p_x - 1) + grayImg.At<byte>(p_y + 2, p_x - 1));

                if ((inner - outer) / 6 > diff_Threshold) {
                    top = new Point(p_x, p_y);
                    break;
                }
            }

            center_point = find_circle_center_3Point(left, right, top);

        }

        public void setOffsetTable(string csv_path, double LensMagnification, double CameraPixelSize)
        {
            StreamReader reader = new StreamReader(csv_path);
            string[] headers = reader.ReadLine().Split('\t');
            int cnt = 0;
            theta_list = new double[36000];
            offset_list = new double[36000];
            while (!reader.EndOfStream) {
                string[] rows = reader.ReadLine().Split(',');
                theta_list[cnt] = Double.Parse(rows[0]);
                offset_list[cnt] = Double.Parse(rows[1]) * LensMagnification / CameraPixelSize * 1000;
                cnt += 1;
            }
        }

        // 이은지 연구원 코드 변환 부분
        public bool FindEdge(Mat srcImg, double radius, double margin, int divide, double diff_Threshold, int centerX, int centerY, int shrinkPixel1, int shrinkPixel2, int shrinkPixel3, int shrinkPixel4, double DetectPointPercent, out Point[][] points_list)
        {
            if (radius==0 || margin==0 || divide==0 || diff_Threshold==0) {
                points_list = new Point[1][];
                points_list[0] = new Point[0];

                Log.E(string.Format("Check the Input Parameters"));
                return false;

            }
            Mat grayImg = new Mat();
            Cv2.CvtColor(srcImg, grayImg, ColorConversionCodes.BGR2GRAY);
            int height = grayImg.Height;
            int width = grayImg.Width;
            Point center = new Point(0,0);
            int p_x1 = width - 10;
            int p_y1 = height / 2;
            Point P1 = new Point(0, 0);
            int p_x2 = 10;
            int p_y2 = height / 2;
            Point P2 = new Point(0, 0);
            int p_x3 = width / 2;
            int p_y3 = 10;
            Point P3 = new Point(0, 0);
            for (int i = 0; i <= 5; i++) {

                while (p_x1 > (width / 2)) {
                    p_x1--;
                    double outer = Convert.ToDouble(grayImg.At<byte>(p_y1, p_x1 + 1) + grayImg.At<byte>(p_y1, p_x1 + 2));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y1 - 1, p_x1 + 1) + grayImg.At<byte>(p_y1 - 1, p_x1 + 2));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y1 + 1, p_x1 + 1) + grayImg.At<byte>(p_y1 + 1, p_x1 + 2));

                    double inner = Convert.ToDouble(grayImg.At<byte>(p_y1, p_x1 - 2) + grayImg.At<byte>(p_y1, p_x1 - 1));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y1 - 1, p_x1 - 2) + grayImg.At<byte>(p_y1 - 1, p_x1 - 1));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y1 + 1, p_x1 - 2) + grayImg.At<byte>(p_y1 + 1, p_x1 - 1));

                    if ((inner - outer) / 6 > diff_Threshold) {
                        P1 = new Point(p_x1, p_y1);
                        break;
                    }
                }

                while (p_x2 < (width / 2)) {
                    p_x2++;
                    double outer = Convert.ToDouble(grayImg.At<byte>(p_y2, p_x2 - 1) + grayImg.At<byte>(p_y2, p_x2 - 2));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y2 + 1, p_x2 - 1) + grayImg.At<byte>(p_y2 + 1, p_x2 - 2));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y2 - 1, p_x2 - 1) + grayImg.At<byte>(p_y2 - 1, p_x2 - 2));

                    double inner = Convert.ToDouble(grayImg.At<byte>(p_y2, p_x2 + 2) + grayImg.At<byte>(p_y2, p_x2 + 1));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y2 + 1, p_x2 + 2) + grayImg.At<byte>(p_y2 + 1, p_x2 + 1));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y2 - 1, p_x2 + 2) + grayImg.At<byte>(p_y2 - 1, p_x2 + 1));

                    if ((inner - outer) / 6 > diff_Threshold) {
                        P2 = new Point(p_x2, p_y2);
                        break;
                    }
                }

                while (p_y3 < (height / 2)) {
                    p_y3++;
                    double outer = Convert.ToDouble(grayImg.At<byte>(p_y3 - 1, p_x3) + grayImg.At<byte>(p_y3 - 2, p_x3));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y3 - 1, p_x3 + 1) + grayImg.At<byte>(p_y3 - 2, p_x3 + 1));
                    outer += Convert.ToDouble(grayImg.At<byte>(p_y3 - 1, p_x3 - 1) + grayImg.At<byte>(p_y3 - 2, p_x3 - 1));

                    double inner = Convert.ToDouble(grayImg.At<byte>(p_y3 + 1, p_x3) + grayImg.At<byte>(p_y3 + 2, p_x3));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y3 + 1, p_x3 + 1) + grayImg.At<byte>(p_y3 + 2, p_x3 + 1));
                    inner += Convert.ToDouble(grayImg.At<byte>(p_y3 + 1, p_x3 - 1) + grayImg.At<byte>(p_y3 + 2, p_x3 - 1));

                    if ((inner - outer) / 6 > diff_Threshold) {
                        P3 = new Point(p_x3, p_y3);
                        break;
                    }
                }

                // 여기까지하면 theshold 차이가 나는 점 3개를 찾은것임.
                // 점 3개로 원의 중심을 찾고, 원 중심에서부터 각도방향으로 threshod 차이나는 엣지를 찾는다.
                center = find_circle_center_3Point(P1, P2, P3);
                if (Math.Abs(center.X-centerX) < margin*1.5 && Math.Abs(center.Y - centerY) < margin*1.5) {
                    break;
                }
                if (i == 0) {
                    p_x1 = width - 10;
                    p_y1 = 2*height / 3;
                    p_x2 = 10;
                    p_y2 = 2 * height / 3;
                    p_x3 = 2*width / 3;
                    p_y3 = 10;
                } else if(i == 1){
                    p_x1 = width - 10;
                    p_y1 = height / 3;
                    p_x2 = 10;
                    p_y2 = height / 3;
                    p_x3 = width / 3;
                    p_y3 = 10;
                } else if (i == 3) {
                    p_x1 = width - 10;
                    p_y1 = 2*height / 5;
                    p_x2 = 10;
                    p_y2 = 2*height / 5;
                    p_x3 = 2*width / 5;
                    p_y3 = 10;
                } else if (i == 4) {
                    p_x1 = width - 10;
                    p_y1 = 3 * height / 5;
                    p_x2 = 10;
                    p_y2 = 3 * height / 5;
                    p_x3 = 3 * width / 5;
                    p_y3 = 10;
                } else {
                    points_list = new Point[1][];
                    points_list[0] = new Point[0];

                    Log.E(string.Format("Failed to find a center"));
                    return false;
                }

            }

            // Center Point가 radius + margin 영역 밖인 경우 예외 처리
            if (radius + margin > center.X ||
                radius + margin > center.Y ||
                grayImg.Width - (radius + margin) < center.X ||
                grayImg.Height - (radius + margin) < center.Y) {

                points_list = new Point[1][];
                points_list[0] = new Point[0];

                Log.E("Center Point is outside the radius + margin area.");

                return false;
            }


            List<Point> edge_list = new List<Point>();
            List<double> l_list = new List<double>();
            for (int i = 0; i < divide; i++) {
                double degree = Convert.ToDouble(i) * 360.0 / Convert.ToDouble(divide);
                double l = radius + margin;

                double[] theta_l = new double[3];
                theta_l[0] = degree * Math.PI / 180;
                theta_l[1] = (degree - (360 / (Convert.ToDouble(divide * 3)))) * Math.PI / 180;
                theta_l[2] = (degree + (360 / (Convert.ToDouble(divide * 3)))) * Math.PI / 180;

                while (l > 0) {
                    double point_x = center.X + l * Math.Cos(theta_l[0]);
                    double point_y = center.Y + l * Math.Sin(theta_l[0]);

                    double outer = 0.0;
                    foreach (var theta in theta_l) {
                        int indexX1 = Convert.ToInt32(center.Y + (l + 1) * Math.Sin(theta));
                        int indexX2 = Convert.ToInt32(center.Y + (l + 2) * Math.Sin(theta));
                        int indexY1 = Convert.ToInt32(center.X + (l + 1) * Math.Cos(theta));
                        int indexY2 = Convert.ToInt32(center.X + (l + 2) * Math.Cos(theta));

                        outer += Convert.ToDouble(grayImg.At<byte>(indexX1, indexY1)) +
                                 Convert.ToDouble(grayImg.At<byte>(indexX2, indexY2));
                    }

                    double inner = 0.0;
                    foreach (var theta in theta_l) {
                        int indexX1 = Convert.ToInt32(center.Y + (l - 1) * Math.Sin(theta));
                        int indexX2 = Convert.ToInt32(center.Y + (l - 2) * Math.Sin(theta));
                        int indexY1 = Convert.ToInt32(center.X + (l - 1) * Math.Cos(theta));
                        int indexY2 = Convert.ToInt32(center.X + (l - 2) * Math.Cos(theta));
                        //if (indexX1 < 0) indexX1 += grayImg.Width;
                        //if (indexX2 < 0) indexX2 += grayImg.Width;
                        //if (indexY1 < 0) indexY1 += grayImg.Height;
                        //if (indexY2 < 0) indexY2 += grayImg.Height;

                        inner += Convert.ToDouble(grayImg.At<byte>(indexX1, indexY1)) +
                                 Convert.ToDouble(grayImg.At<byte>(indexX2, indexY2));
                    }

                    if ((inner - outer) / 6 > diff_Threshold) {
                        Point point = new Point(point_x, point_y);
                        edge_list.Add(point);
                        l_list.Add(l);
                        break;
                    }
                    l = l - 1;

                    if (l == radius - margin) {
                        l = radius + margin;
                        degree += (360.0 / Convert.ToDouble(divide * 10));
                        theta_l[0] = degree * Math.PI / 180;
                        theta_l[1] = (degree - (360 / (divide * 3))) * Math.PI / 180;
                        theta_l[2] = (degree + (360 / (divide * 3))) * Math.PI / 180;
                        if (degree >= Convert.ToDouble(i + 1) * 360.0 / Convert.ToDouble(divide))
                            break;
                    }
                }
            }
            double DetectPercent = (double)edge_list.Count / (double)divide * 100;
            if (DetectPercent <= DetectPointPercent) {
                points_list = new Point[1][];
                points_list[0] = new Point[0];

                Log.E(string.Format("Detected Points Percentage is {0}", DetectPercent));

                return false;

            }
            Log.I(string.Format("Detection Points Percentage is {0}", DetectPercent));
            //찌그러짐 interlock
            //1) 전체 Max-Min 값
            //2) 부분(3도 단위) Max-Min 값
            Stopwatch stopwatch = Stopwatch.StartNew();
            double max_diff = l_list.Max()-l_list.Min();
            if (max_diff > eInterlockMaxMinDiff) {
                Log.E($"Invalid Shape (max difference : {max_diff})");
                int ind = 0;
                points_list = new Point[1][];
                points_list[0] = new Point[edge_list.Count];
                foreach (var item in edge_list)
                    points_list[0][ind++] = item;

                // Find max contour
                Point[] mxCnt = points_list.OrderByDescending(c => Cv2.ContourArea(c)).First();
                // Shrink max contour

                //points_list = ShrinkPixelContour(maxCnt, shrinkPixel);
                //Angle Test
                if (is_manual)
                    points_list = ShrinkPixelContourQuad(mxCnt, shrinkPixel1, shrinkPixel2, shrinkPixel3, shrinkPixel4, ShrinkByFunction);
                else
                    points_list = ShrinkPixelContourCSV(mxCnt, theta_list, offset_list);
                return false;
            }
            int window_size = l_list.Count / 12;
            for (int i=0; i<l_list.Count-window_size; i++) {
                double max_val = 0;
                double min_val = double.MaxValue;
                for (int j=0; j < window_size; j++) {
                    if (l_list[i + j] > max_val) {
                        max_val = l_list[i + j];
                    }
                    if (l_list[i + j] < min_val) {
                        min_val = l_list[i + j];
                    }
                }
                if (max_val - min_val > eInterlockMaxMinDiff_local) {
                    Log.E($"Invalid Shape.(max difference : {max_diff})");
                    int ind = 0;
                    points_list = new Point[1][];
                    points_list[0] = new Point[edge_list.Count];
                    foreach (var item in edge_list)
                        points_list[0][ind++] = item;

                    // Find max contour
                    Point[] mxCnt = points_list.OrderByDescending(c => Cv2.ContourArea(c)).First();
                    // Shrink max contour

                    //points_list = ShrinkPixelContour(maxCnt, shrinkPixel);
                    //Angle Test
                    if (is_manual)
                        points_list = ShrinkPixelContourQuad(mxCnt, shrinkPixel1, shrinkPixel2, shrinkPixel3, shrinkPixel4, ShrinkByFunction);
                    else
                        points_list = ShrinkPixelContourCSV(mxCnt, theta_list, offset_list);
                    return false;
                }
            }

            int index = 0;
            points_list = new Point[1][];
            points_list[0] = new Point[edge_list.Count];
            foreach (var item in edge_list)
                points_list[0][index++] = item;

            Point[][] contours;
            HierarchyIndex[] hierarchy;
            // Find max contour
            Point[] maxCnt = points_list.OrderByDescending(c => Cv2.ContourArea(c)).First();
            // Shrink max contour

            //points_list = ShrinkPixelContour(maxCnt, shrinkPixel);
            //Angle Test
            if (is_manual)
                points_list = ShrinkPixelContourQuad(maxCnt, shrinkPixel1, shrinkPixel2, shrinkPixel3, shrinkPixel4, ShrinkByFunction);
            else
                points_list = ShrinkPixelContourCSV(maxCnt, theta_list, offset_list);
            //Point2f center;
            //float radius;
            //Point[] p = shrunkCnt[0];
            //.MinEnclosingCircle(p, out center, out radius);
            DetectedContourCenterPixel.X = center.X;
            DetectedContourCenterPixel.Y = center.Y;
            ConvertDrawingObjectAxis(center.X, center.Y, out DetectedContourCenter);
            ConvertDrawingObjectAxis((float)radius, out fDetectedContourRadius);
            return true;
        }

        private Point find_circle_center_3Point(Point left, Point right, Point top)
        {
            Point center = new Point(0, 0);

            Point mid_AB = (left + right) * 0.5;
            Point mid_BC = (right + top) * 0.5;

            double perp_slope_BC;

            // 나누기 0일 경우
            if (top.X - right.X == 0)
                return center;

            double slope_BC = (Convert.ToDouble(top.Y - right.Y) / Convert.ToDouble(top.X - right.X));
            if (slope_BC != 0)
                perp_slope_BC = -1 / slope_BC;
            else
                perp_slope_BC = mid_AB.Y;
            double x_center = mid_AB.X;
            double y_center = perp_slope_BC * x_center + (mid_BC.Y - perp_slope_BC * mid_BC.X);

            center = new Point(x_center, y_center);

            return center;
        }

        public (int, int, double, double, int, int, int, int, double) FindOffset(Mat imageColor, double threshold, int X, int Y, double T, out Point[][] out_contours, string SelectedOption)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            if( X==0 && Y == 0) {
                Log.E("No Reference Information");
                out_contours = new Point[1][];
                out_contours[0] = new Point[0];
                return (-1, -1, -1, -1, -1, -1, -1, -1, -1);
            }
            if (SelectedOption == "Inzi") {
                Mat grayImage = new Mat();
                Cv2.CvtColor(imageColor, grayImage, ColorConversionCodes.BGR2GRAY);

                int width = (int)(grayImage.Width / 4);
                int height = (int)(grayImage.Height / 4);
                Mat resizedImage = new Mat();
                Cv2.Resize(grayImage, resizedImage, new Size(width, height), interpolation: InterpolationFlags.Linear);
                Mat thres = new Mat();
                Cv2.Threshold(resizedImage, thres, threshold, 200, ThresholdTypes.Binary);

                Point[][] contours;
                HierarchyIndex[] hierarchy;
                Cv2.FindContours(thres, out contours, out hierarchy, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
                Mat thres_img = new Mat();
                Cv2.Threshold(resizedImage, thres_img, 1, 200, ThresholdTypes.Binary);
                Point[][] contours_image;
                HierarchyIndex[] hierarchy_;
                Cv2.FindContours(thres_img, out contours_image, out hierarchy_, RetrievalModes.External, ContourApproximationModes.ApproxSimple);
                OpenCvSharp.Rect ImgRect = Cv2.BoundingRect(contours_image[0]);
                Point topleft = ImgRect.TopLeft;
                Point bottomright = ImgRect.BottomRight;
                List<(double area, int index)> contourList = new List<(double, int)>();
                for (int i = 0; i < contours.Length; i++) {
                    double area = Cv2.ContourArea(contours[i]);
                    if (area < 100) continue;
                    OpenCvSharp.Rect boundingRect = Cv2.BoundingRect(contours[i]);
                    if (boundingRect.TopLeft.X - topleft.X < 10 || boundingRect.TopLeft.Y - topleft.Y < 10 || bottomright.X - boundingRect.BottomRight.X < 10 || bottomright.Y - boundingRect.BottomRight.Y < 10) {
                        //가장자리 Case
                        continue;
                    }
                    contourList.Add((area, i));
                }
                if (contourList.Count < 2) {
                    out_contours = new Point[2][];
                    out_contours[0] = new Point[0];
                    out_contours[1] = new Point[0];
                    return (-1, -1, -1, -1, -1, -1, -1, -1, -1);
                }
                contourList.Sort((x, y) => x.area.CompareTo(y.area));
                var circle = contours[contourList[contourList.Count - 1].index];
                var square = contours[contourList[contourList.Count - 2].index];

                Moments circleMoments = Cv2.Moments(circle);
                double cX = (circleMoments.M10 / circleMoments.M00) * 4;
                double cY = (circleMoments.M01 / circleMoments.M00) * 4;

                Moments squareMoments = Cv2.Moments(square);
                double ScX = (squareMoments.M10 / squareMoments.M00) * 4;
                double ScY = (squareMoments.M01 / squareMoments.M00) * 4;

                double Otheta = ScX == cX ? 0 : Math.Atan((ScY - cY) / (ScX - cX));
                if (Otheta < 0 && (ScX - cX) >= 0) {
                    Otheta = -Otheta;
                } else if (Otheta >= 0 && (ScX - cX) >= 0) {
                    Otheta = -Otheta;
                } else if (Otheta >= 0 && (ScX - cX) < 0) {
                    Otheta = Math.PI - Otheta;
                } else {
                    Otheta = Math.PI - Otheta;
                }


                for (int i = 0; i < square.Length; i++) {
                    square[i].X *= 4;
                    square[i].Y *= 4;
                }
                double dist = 0;
                for (int i = 0; i < circle.Length; i++) {
                    circle[i].X *= 4;
                    circle[i].Y *= 4;
                    dist += Math.Sqrt((circle[i].X - cX) * (circle[i].X - cX) + (circle[i].Y - cY) * (circle[i].Y - cY));
                }
                dist = dist / circle.Length;
                out_contours = new Point[2][];
                out_contours[0] = circle;
                out_contours[1] = square;
                return ((int)cX - X, (int)cY - Y, Otheta, Otheta - T, (int)cX, (int)cY, (int)ScX, (int)ScY, dist);
            } else {
                int point_num = 1000;
                Point[] points = new Point[point_num];
                int[] l_l = new int[point_num];
                int[] diff_l = new int[point_num];
                //TODO : Start, End(610) 파라미터화
                for (int t_i = 0; t_i < point_num; t_i++) {
                    double t = (double)t_i / (double)point_num * 360.0;
                    int sum = 0;
                    int max_diff = -int.MaxValue;
                    int outer = 0;
                    int inner = 0;
                    int max_sum = 0;
                    int max_l = 0;
                    int start = 410;
                    int end = 610;
                    int line_width = 30;
                    if (X+ end >= imageColor.Width || Y+end >= imageColor.Width || X-end <= 0 || Y-end <= 0) {
                        Log.E("Wrong Reference Point.");
                        out_contours = new Point[1][];
                        out_contours[0] = new Point[0];
                        return (-1, -1, -1, -1, -1, -1, -1, -1, -1);
                    }
                    for (int l = start; l < end; l=l+3) {
                        Point p = new Point(X + (int)(l * Math.Cos(t * Math.PI / 180)), Y + (int)(l * Math.Sin(t * Math.PI / 180)));
                        sum += imageColor.At<byte>(p.Y, p.X);

                        if (l < start + line_width) inner += imageColor.At<byte>(p.Y, p.X);
                        else if (l==start+ line_width) outer += imageColor.At<byte>(p.Y, p.X);
                        else if (l < start + line_width*2) {
                            outer += imageColor.At<byte>(p.Y, p.X);
                            inner += imageColor.At<byte>(Y + (int)((l - (l - start- line_width)) * Math.Sin(t * Math.PI / 180)), X + (int)((l - (l- start- line_width)) * Math.Cos(t * Math.PI / 180)));
                            inner -= imageColor.At<byte>(Y + (int)((l - (l - start- line_width*2)) * Math.Sin(t * Math.PI / 180)), X + (int)((l - (l - start- line_width*2)) * Math.Cos(t * Math.PI / 180)));
                        }
                        else {
                            outer += imageColor.At<byte>(p.Y, p.X);
                            outer -= imageColor.At<byte>(Y + (int)((l - line_width) * Math.Sin(t * Math.PI / 180)), X + (int)((l - line_width) * Math.Cos(t * Math.PI / 180)));
                            inner += imageColor.At<byte>(Y + (int)((l - line_width) * Math.Sin(t * Math.PI / 180)), X + (int)((l - line_width) * Math.Cos(t * Math.PI / 180)));
                            inner -= imageColor.At<byte>(Y + (int)((l - line_width*2) * Math.Sin(t * Math.PI / 180)), X + (int)((l - line_width*2) * Math.Cos(t * Math.PI / 180)));
                        }
                        int diff = outer - inner;
                        if (diff > max_diff) {
                            max_diff = diff;
                            max_l = l - line_width;
                            points[t_i] = new Point(X + (int)((l - line_width) * Math.Cos(t * Math.PI / 180)), Y + (int)((l - line_width) * Math.Sin(t * Math.PI / 180)));
                        }
                        if (sum > max_sum) max_sum = sum;
                    }
                    l_l[t_i] = max_l;
                    diff_l[t_i] = max_diff;
                }

                double diff_l_avg = diff_l.Average();
                out_contours = new Point[1][];
                out_contours[0] = points;
                double min_sum_ = double.MaxValue;
                int min_t = 0;
                int sum_distance = 0;
                int sum_diff = 0;
                int search_size = 30;
                int x_cor_sum = 0; int x_cor_n = 0;
                int y_cor_sum = 0; int y_cor_n = 0;
                for (int t = 0; t < point_num/3; t++) {
                    sum_distance += (l_l[t] + l_l[t + point_num/3] + l_l[t + point_num*2/3]);
                    sum_diff += (diff_l[t] + diff_l[t + point_num / 3] + diff_l[t + point_num * 2 / 3]);
                    if (t < search_size) continue;
                    sum_distance -= (l_l[t- search_size] + l_l[t + point_num/3- search_size] + l_l[t + point_num*2/3 - search_size]);
                    sum_diff -= (diff_l[t - search_size] + diff_l[t + point_num / 3 - search_size] + diff_l[t + point_num * 2 / 3 - search_size]);
                    if ((float)sum_diff < diff_l_avg* (float)search_size*3) continue;
                    if ((float)sum_diff > diff_l_avg * (float)search_size * 3) {
                        x_cor_sum += (points[t].X + points[t + point_num / 3].X + points[t + point_num * 2 / 3].X);
                        y_cor_sum += (points[t].Y + points[t + point_num / 3].Y + points[t + point_num * 2 / 3].Y);
                        x_cor_n += 3;
                        y_cor_n += 3;
                    }

                    if (sum_distance < min_sum_) {
                        min_sum_ = sum_distance;
                        min_t = t- search_size/2;
                    }

                }
                if (x_cor_n == 0) {
                    out_contours = new Point[1][];
                    out_contours[0] = new Point[0];
                    return (-1, -1, -1, -1, -1, -1, -1, -1, -1);
                }
                double theta = (double)min_t / (double)point_num * 360.0;
                Console.WriteLine($"Delta theta: {theta}");
                //Log.I($"Elapsed time: {stopwatch.Elapsed.TotalSeconds}");
                int new_X = (int)(x_cor_sum / x_cor_n);
                int new_Y = (int)(y_cor_sum / y_cor_n);
                return (new_X - X, new_Y - Y, theta, -theta + T * 180 / Math.PI, new_X, new_Y, X + (int)(l_l[min_t] * Math.Cos(theta * Math.PI / 180)), Y + (int)(l_l[min_t] * Math.Sin(theta * Math.PI / 180)), 0);

            }
        }
    }
}