HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using Llama;

using Plaice;

using Ingr.RAD2D.Interop.RAD2D;

using Ingr.RAD2D.Internal;

using Ingr.RAD2D.Helper;

using Converter.BaseModel;

using Converter.SPPID.Model;

using Converter.SPPID.Properties;

using Converter.SPPID.Util;

using Converter.SPPID.DB;

using Ingr.RAD2D.MacroControls.CmdCtrl;

using Ingr.RAD2D;

using System.Windows;

using System.Threading;

using System.Drawing;

using Microsoft.VisualBasic;

using Newtonsoft.Json;

using DevExpress.XtraSplashScreen;

namespace Converter.SPPID

{

    public class AutoModeling

    {

        Placement _placement;

        LMADataSource dataSource;

        dynamic newDrawing;

        dynamic application;

        Ingr.RAD2D.Application radApp;

        SPPID_Document document;

        ETCSetting _ETCSetting;

        public string DocumentLabelText { get; set; }

        int CurrentCount;

        List <Tuple<string, Line, Line>> BranchLines = new List<Tuple<string, Line, Line>>();

        public AutoModeling(SPPID_Document document, dynamic application, Ingr.RAD2D.Application radApp)

        {

            this.document = document;

            this.application = application;

            this.radApp = radApp;

            this._ETCSetting = ETCSetting.GetInstance();

        }

        private int ClacProgressCount()

        {

            int EquipCount = 0;

            int SymbolCount = 0;

            int LineCount = 0;

            int NoteCount = 0;

            int TextCount = 0;

            int EndBreakCount = 0;

            int LineNumberCount = 0;

            EquipCount = document.Equipments.Count;

            SymbolCount = document.SYMBOLS.Count;

            SymbolCount = SymbolCount * 3;

            foreach (LineNumber lineNumber in document.LINENUMBERS)

                foreach (LineRun run in lineNumber.RUNS)

                    foreach (var item in run.RUNITEMS)

                        if (item.GetType() == typeof(Line))

                            LineCount++;

            foreach (TrimLine trimLine in document.TRIMLINES)

                foreach (LineRun run in trimLine.RUNS)

                    foreach (var item in run.RUNITEMS)

                        if (item.GetType() == typeof(Line))

                            LineCount++;

            LineCount = LineCount * 2;

            NoteCount = document.NOTES.Count;

            TextCount = document.TEXTINFOS.Count;

            EndBreakCount = document.EndBreaks.Count;

            LineNumberCount = document.LINENUMBERS.Count;

            LineNumberCount = LineNumberCount * 2;

            return EquipCount + SymbolCount + LineCount + NoteCount + TextCount + EndBreakCount;

        }

        /// <summary>

        /// 도면 단위당 실행되는 메서드

        /// </summary>

        public void Run()

        {

            try

            {

                _placement = new Placement();

                dataSource = _placement.PIDDataSource;

                CreateDocument();

                if (DocumentCoordinateCorrection())

                {

                    int AllCount = ClacProgressCount();

                    SplashScreenManager.ShowForm(typeof(SPPIDSplashScreen), true, true);

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetAllStep, AllCount);

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetDocumentName, DocumentLabelText);

                    //Thread.Sleep(1000);

                    //SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetParent, (IntPtr)radApp.HWnd);

                    //Thread.Sleep(1000);

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Group Symbol Modeling");

                    List<List<Symbol>> symbolGroups = SPPIDUtil.GetThreeConnectedSymbolGroup(document);

                    foreach (List<Symbol> symbolGroup in symbolGroups)

                        SymbolModelingByThreeSymbolGroup(symbolGroup);

                    // Equipment Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Equipments Modeling");

                    foreach (Equipment equipment in document.Equipments)

                        EquipmentModeling(equipment);

                    // LineRun Symbol Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Symbols Modeling");

                    foreach (LineNumber lineNumber in document.LINENUMBERS)

                        foreach (LineRun run in lineNumber.RUNS)

                            SymbolModelingByRun(run);

                    // TrimLineRun Symbol Modeling

                    foreach (TrimLine trimLine in document.TRIMLINES)

                        foreach (LineRun run in trimLine.RUNS)

                            SymbolModelingByRun(run);

                    // LineRun Line Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Lines Modeling");

                    foreach (LineNumber lineNumber in document.LINENUMBERS)

                        foreach (LineRun run in lineNumber.RUNS)

                            LineModelingByRun(run);

                    // TrimLineRun Line Modeling

                    foreach (TrimLine trimLine in document.TRIMLINES)

                        foreach (LineRun run in trimLine.RUNS)

                            LineModelingByRun(run);

                    // Branch Line Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Branch Lines Modeling");

                    foreach (var item in BranchLines)

                        BranchLineModeling(item);

                    // EndBreak Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "EndBreaks Modeling");

                    foreach (var item in document.EndBreaks)

                        EndBreakModeling(item);

                    // LineNumber Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "LineNumbers Modeling");

                    foreach (var item in document.LINENUMBERS)

                        LineNumberModeling(item);

                    // LineNumber Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Flow Mark Modeling");

                    foreach (var item in document.LINES)

                        FlowMarkModeling(item);

                    // Note Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Notes Modeling");

                    foreach (var item in document.NOTES)

                        NoteModeling(item);

                    // Text Modeling

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Texts Modeling");

                    foreach (var item in document.TEXTINFOS)

                        TextModeling(item);

                    // LineRun Line Join

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Join LineRuns");

                    foreach (LineNumber lineNumber in document.LINENUMBERS)

                        foreach (LineRun run in lineNumber.RUNS)

                            JoinRunLine(run);

                    // TrimLineRun Line Join

                    foreach (TrimLine trimLine in document.TRIMLINES)

                        foreach (LineRun run in trimLine.RUNS)

                            JoinRunLine(run);

                    // Input LineNumber Attribute

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Set Lines Attribute");

                    foreach (var item in document.LINENUMBERS)

                        InputLineNumberAttribute(item);

                    // Input Symbol Attribute

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Set Symbols Attribute");

                    foreach (var item in document.SYMBOLS)

                        InputSymbolAttribute(item, item.ATTRIBUTES);

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetStep, "Labels Modeling");

                    foreach (var item in document.SYMBOLS)

                        LabelSymbolModeling(item);

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, AllCount);

                }

            }

            catch (Exception ex)

            {

                System.Windows.Forms.MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace);

            }

            finally

            {

                application.ActiveWindow.Fit();

                if (newDrawing != null)

                {

                    radApp.ActiveDocument.SaveOnClose = false;

                    radApp.ActiveDocument.Save();

                    ReleaseCOMObjects(newDrawing);

                }

                ReleaseCOMObjects(dataSource);

                ReleaseCOMObjects(_placement);

                //SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.ClearParent, null);

                SplashScreenManager.CloseForm(false);

            }

        }

        /// <summary>

        /// 도면 생성 메서드

        /// </summary>

        private void CreateDocument()

        {

            newDrawing = application.Drawings.Add(document.Unit, document.Template, document.DrawingNumber, document.DrawingName);

            application.ActiveWindow.Fit();

            Thread.Sleep(1000);

            application.ActiveWindow.Zoom = 2000;

            Thread.Sleep(2000);

        }

        /// <summary>

        /// 도면 크기 구하는 메서드

        /// </summary>

        /// <returns></returns>

        private bool DocumentCoordinateCorrection()

        {

            double maxX = 0;

            double maxY = 0;

            foreach (object drawingObj in radApp.ActiveDocument.ActiveSheet.DrawingObjects)

            {

                Ingr.RAD2D.SmartFrame2d smartFrame2d = drawingObj as Ingr.RAD2D.SmartFrame2d;

                if (smartFrame2d != null)

                {

                    double x1 = 0;

                    double x2 = 0;

                    double y1 = 0;

                    double y2 = 0;

                    smartFrame2d.Range(out x1, out y1, out x2, out y2);

                    maxX = Math.Max(x2, maxX);

                    maxY = Math.Max(y2, maxY);

                }

            }

            if (maxX != 0 && maxY != 0)

            {

                document.SetSPPIDLocation(maxX, maxY);

                return true;

            }

            else

                return false;

        }

        /// <summary>

        /// 라인을 Run 단위로 모델링하는 진입 메서드

        /// </summary>

        /// <param name="run"></param>

        private void LineModelingByRun(LineRun run)

        {

            Line prevLine = null;

            List<Line> lines = new List<Line>();

            foreach (var item in run.RUNITEMS)

            {

                // Line일 경우

                if (item.GetType() == typeof(Line))

                {

                    Line line = item as Line;

                    if (prevLine == null)

                        lines.Add(line);

                    else if (prevLine != null)

                    {

                        if (prevLine.SPPID.MAPPINGNAME == line.SPPID.MAPPINGNAME)

                            lines.Add(line);

                        else

                        {

                            if (lines.Count > 0)

                            {

                                LineModeling(lines);

                                lines.Clear();

                            }

                            lines.Add(line);

                        }

                    }

                    prevLine = line;

                    SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, ++CurrentCount);

                }

                // Symbol 일 경우

                else if (item.GetType() == typeof(Symbol))

                {

                    if (lines.Count > 0)

                    {

                        LineModeling(lines);

                        lines.Clear();

                    }

                }

            }

            if (lines.Count > 0)

                LineModeling(lines);

        }

        /// <summary>

        /// 심볼을 Run 단위로 모델링하는 진입 메서드

        /// </summary>

        /// <param name="run"></param>

        private void SymbolModelingByRun(LineRun run)

        {

            // 양끝 Symbol 검사 후 Line이 나올때까지만 Symbol Modeling

            if (run.RUNITEMS.Count > 0)

            {

                if (run.RUNITEMS[0].GetType() == typeof(Symbol))

                    SymbolModelingByRunStart(run.RUNITEMS[0] as Symbol, run);

                if (run.RUNITEMS[run.RUNITEMS.Count - 1].GetType() == typeof(Symbol))

                    SymbolModelingByRunEnd(run.RUNITEMS[run.RUNITEMS.Count - 1] as Symbol, run);

            }

            Symbol targetSymbol = null;

            foreach (var item in run.RUNITEMS)

            {

                if (item.GetType() == typeof(Symbol))

                {

                    Symbol symbol = item as Symbol;

                    SymbolModeling(symbol, targetSymbol);

                    targetSymbol = symbol;

                }

                else

                {

                    targetSymbol = null;

                }

            }

        }

        /// <summary>

        /// Run에 있는 심볼을 모델링하는데 기준이 Run의 시작점

        /// </summary>

        /// <param name="symbol"></param>

        /// <param name="run"></param>

        private void SymbolModelingByRunStart(Symbol symbol, LineRun run)

        {

            foreach (var connector in symbol.CONNECTORS)

            {

                object targetItem = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM);

                if (targetItem != null &&

                    (targetItem.GetType() == typeof(Symbol) || targetItem.GetType() == typeof(Equipment)) &&

                    !IsSameLineRun(symbol, targetItem))

                {

                    SymbolModeling(symbol, targetItem as Symbol);

                    for (int i = 1; i < run.RUNITEMS.Count; i++)

                    {

                        object item = run.RUNITEMS[i];

                        if (item.GetType() == typeof(Symbol))

                            SymbolModeling(item as Symbol, run.RUNITEMS[i - 1] as Symbol);

                        else

                            break;

                    }

                    break;

                }

            }

        }

        /// <summary>

        /// Run에 있는 심볼을 모델링하는데 기준이 Run의 끝점

        /// </summary>

        /// <param name="symbol"></param>

        /// <param name="run"></param>

        private void SymbolModelingByRunEnd(Symbol symbol, LineRun run)

        {

            foreach (var connector in symbol.CONNECTORS)

            {

                object targetItem = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM);

                if (targetItem != null &&

                    (targetItem.GetType() == typeof(Symbol) || targetItem.GetType() == typeof(Equipment)) &&

                    !IsSameLineRun(symbol, targetItem))

                {

                    SymbolModeling(symbol, targetItem as Symbol);

                    for (int i = run.RUNITEMS.Count - 2; i >= 0; i--)

                    {

                        object item = run.RUNITEMS[i];

                        if (item.GetType() == typeof(Symbol))

                            SymbolModeling(item as Symbol, run.RUNITEMS[i + 1] as Symbol);

                        else

                            break;

                    }

                    break;

                }

            }

        }

        /// <summary>

        /// 심볼을 실제로 Modeling 메서드

        /// </summary>

        /// <param name="symbol"></param>

        /// <param name="targetSymbol"></param>

        /// <param name="prevSymbol"></param>

        private void SymbolModeling(Symbol symbol, Symbol targetSymbol)

        {

            // OWNERSYMBOL Attribute, 값을 가지고 있을 경우

            BaseModel.Attribute itemAttribute = symbol.ATTRIBUTES.Find(attr => attr.ATTRIBUTE == "OWNERSYMBOL");

            if (itemAttribute != null && string.IsNullOrEmpty(itemAttribute.VALUE) && itemAttribute.VALUE != "None")

                return;

            // 이미 모델링 됐을 경우

            else if (!string.IsNullOrEmpty(symbol.SPPID.RepresentationId))

                return;

            LMSymbol _LMSymbol = null;

            string mappingPath = symbol.SPPID.MAPPINGNAME;

            double x = symbol.SPPID.ORIGINAL_X;

            double y = symbol.SPPID.ORIGINAL_Y;

            int mirror = 0;

            double angle = symbol.ANGLE;

            SPPIDUtil.ConvertGridPoint(ref x, ref y);

            // OPC 일경우 180도 일때 Mirror

            if (mappingPath.Contains("Piping OPC's") && angle == Math.PI)

                mirror = 1;

            if (targetSymbol != null && !string.IsNullOrEmpty(targetSymbol.SPPID.RepresentationId))

            {

                LMSymbol _TargetItem = dataSource.GetSymbol(targetSymbol.SPPID.RepresentationId);

                Connector connector = SPPIDUtil.FindSymbolConnectorByUID(document, symbol.UID, targetSymbol);

                if (connector != null)

                    GetTargetSymbolConnectorPoint(connector, targetSymbol, ref x, ref y);

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle, TargetItem: _TargetItem);

                ReleaseCOMObjects(_TargetItem);

            }

            else

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

            if (_LMSymbol != null)

            {

                _LMSymbol.Commit();

                symbol.SPPID.RepresentationId = _LMSymbol.AsLMRepresentation().Id;

                symbol.SPPID.GraphicOID = _LMSymbol.get_GraphicOID();

                foreach (var item in symbol.ChildSymbols)

                    CreateChildSymbol(item, _LMSymbol);

            }

            ReleaseCOMObjects(_LMSymbol);

            SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, ++CurrentCount);

        }

        /// <summary>

        /// ID2의 Symbol Width와 Height를 비교해서 상대적인 SPPID Connector좌표를 가져온다.

        /// </summary>

        /// <param name="targetConnector"></param>

        /// <param name="targetSymbol"></param>

        /// <param name="x"></param>

        /// <param name="y"></param>

        private void GetTargetSymbolConnectorPoint(Connector targetConnector, Symbol targetSymbol, ref double x, ref double y)

        {

            LMSymbol _TargetItem = dataSource.GetSymbol(targetSymbol.SPPID.RepresentationId);

            double[] range = null;

            List<double[]> points = new List<double[]>();

            GetSPPIDSymbolRangeAndConnectionPoints(targetSymbol, ref range, points);

            double x1 = range[0];

            double y1 = range[1];

            double x2 = range[2];

            double y2 = range[3];

            // Origin 기준 Connector의 위치차이

            double sceneX = 0;

            double sceneY = 0;

            SPPIDUtil.ConvertPointBystring(targetConnector.SCENECONNECTPOINT, ref sceneX, ref sceneY);

            double originX = 0;

            double originY = 0;

            SPPIDUtil.ConvertPointBystring(targetSymbol.ORIGINALPOINT, ref originX, ref originY);

            double gapX = originX - sceneX;

            double gapY = originY - sceneY;

            // SPPID Symbol과 ID2 심볼의 크기 차이

            double sizeWidth = 0;

            double sizeHeight = 0;

            SPPIDUtil.ConvertPointBystring(targetSymbol.SIZE, ref sizeWidth, ref sizeHeight);

            double percentX = (x2 - x1) / sizeWidth;

            double percentY = (y2 - y1) / sizeHeight;

            double SPPIDgapX = gapX * percentX;

            double SPPIDgapY = gapY * percentY;

            double[] SPPIDOriginPoint = new double[] { _TargetItem.get_XCoordinate() - SPPIDgapX, _TargetItem.get_YCoordinate() + SPPIDgapY };

            double distance = double.MaxValue;

            double[] resultPoint;

            foreach (var point in points)

            {

                double result = SPPIDUtil.CalcPointToPointdDistance(point[0], point[1], SPPIDOriginPoint[0], SPPIDOriginPoint[1]);

                if (distance > result)

                {

                    distance = result;

                    resultPoint = point;

                    x = point[0];

                    y = point[1];

                }

            }

            ReleaseCOMObjects(_TargetItem);

        }

        /// <summary>

        /// SPPID Symbol의 Range를 구한다.

        /// </summary>

        /// <param name="symbol"></param>

        /// <param name="range"></param>

        private void GetSPPIDSymbolRangeAndConnectionPoints(Symbol symbol, ref double[] range, List<double[]> points)

        {

            LMSymbol _TargetItem = dataSource.GetSymbol(symbol.SPPID.RepresentationId);

            Ingr.RAD2D.Symbol2d symbol2d = radApp.ActiveDocument.ActiveSheet.DrawingObjects[_TargetItem.get_GraphicOID().ToString()];

            double x1 = 0;

            double y1 = 0;

            double x2 = 0;

            double y2 = 0;

            symbol2d.Range(out x1, out y1, out x2, out y2);

            range = new double[] { x1, y1, x2, y2 };

            for (int i = 1; i < int.MaxValue; i++)

            {

                double connX = 0;

                double connY = 0;

                if (_placement.PIDConnectPointLocation(_TargetItem, i, ref connX, ref connY))

                    points.Add(new double[] { connX, connY });

                else

                    break;

            }

            foreach (var childSymbol in symbol.ChildSymbols)

                GetSPPIDChildSymbolRange(childSymbol, ref range, points);

            ReleaseCOMObjects(_TargetItem);

        }

        /// <summary>

        /// Child Modeling 된 Symbol의 Range를 구한다.

        /// </summary>

        /// <param name="childSymbol"></param>

        /// <param name="range"></param>

        private void GetSPPIDChildSymbolRange(ChildSymbol childSymbol, ref double[] range, List<double[]> points)

        {

            LMSymbol _ChildSymbol = dataSource.GetSymbol(childSymbol.SPPID.RepresentationId);

            Ingr.RAD2D.Symbol2d symbol2d = radApp.ActiveDocument.ActiveSheet.DrawingObjects[_ChildSymbol.get_GraphicOID().ToString()];

            double x1 = 0;

            double y1 = 0;

            double x2 = 0;

            double y2 = 0;

            symbol2d.Range(out x1, out y1, out x2, out y2);

            range[0] = Math.Min(range[0], x1);

            range[1] = Math.Min(range[1], y1);

            range[2] = Math.Max(range[2], x2);

            range[3] = Math.Max(range[3], y2);

            for (int i = 1; i < int.MaxValue; i++)

            {

                double connX = 0;

                double connY = 0;

                if (_placement.PIDConnectPointLocation(_ChildSymbol, i, ref connX, ref connY))

                    points.Add(new double[] { connX, connY });

                else

                    break;

            }

            foreach (var loopChildSymbol in childSymbol.ChildSymbols)

                GetSPPIDChildSymbolRange(loopChildSymbol, ref range, points);

            ReleaseCOMObjects(_ChildSymbol);

        }

        /// <summary>

        /// Label Symbol Modeling

        /// </summary>

        /// <param name="symbol"></param>

        private void LabelSymbolModeling(Symbol symbol)

        {

            BaseModel.Attribute itemAttribute = symbol.ATTRIBUTES.Find(x => x.ATTRIBUTE == "OWNERSYMBOL");

            if (itemAttribute == null || string.IsNullOrEmpty(itemAttribute.VALUE))

                return;

            Array points = new double[] { 0, symbol.SPPID.ORIGINAL_X, symbol.SPPID.ORIGINAL_Y };

            string symbolUID = itemAttribute.VALUE;

            object targetItem = SPPIDUtil.FindObjectByUID(document, symbolUID);

            if (targetItem != null)

            {

                // Object 아이템이 Symbol일 경우 Equipment일 경우 

                string sRep = null;

                if (targetItem.GetType() == typeof(Symbol))

                    sRep = ((Symbol)targetItem).SPPID.RepresentationId;

                else if (targetItem.GetType() == typeof(Equipment))

                    sRep = ((Equipment)targetItem).SPPID.RepresentationId;

                if (!string.IsNullOrEmpty(sRep))

                {

                    // LEADER Line 검사

                    bool leaderLine = false;

                    SymbolMapping symbolMapping = document.SymbolMappings.Find(x => x.UID == symbol.DBUID);

                    if (symbolMapping != null)

                        leaderLine = symbolMapping.LEADERLINE;

                    // Target Symbol Item 가져오고 Label Modeling

                    LMSymbol _TargetItem = dataSource.GetSymbol(sRep);

                    LMLabelPersist _LMLabelPresist = _placement.PIDPlaceLabel(symbol.SPPID.MAPPINGNAME, ref points, Rotation: 0, LabeledItem: _TargetItem.AsLMRepresentation(), IsLeaderVisible: leaderLine);

                    //Leader 선 센터로

                    if (_LMLabelPresist != null)

                    {

                        // Target Item에 Label의 Attribute Input

                        InputSymbolAttribute(targetItem, symbol.ATTRIBUTES);

                        string OID = _LMLabelPresist.get_GraphicOID();

                        DependencyObject dependency = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID] as DependencyObject;

                        if (dependency != null)

                        {

                            bool result = false;

                            foreach (var attributes in dependency.AttributeSets)

                            {

                                foreach (var attribute in attributes)

                                {

                                    string name = attribute.Name;

                                    string value = attribute.GetValue().ToString();

                                    if (name == "DrawingItemType" && value == "LabelPersist")

                                    {

                                        foreach (DrawingObjectBase drawingObject in dependency.DrawingObjects)

                                        {

                                            if (drawingObject.Type == Ingr.RAD2D.ObjectType.igLineString2d)

                                            {

                                                Ingr.RAD2D.LineString2d lineString2D = drawingObject as Ingr.RAD2D.LineString2d;

                                                double prevX = _TargetItem.get_XCoordinate();

                                                double prevY = _TargetItem.get_YCoordinate();

                                                lineString2D.InsertVertex(lineString2D.VertexCount, prevX, prevY);

                                                lineString2D.RemoveVertex(lineString2D.VertexCount);

                                                result = true;

                                                break;

                                            }

                                        }

                                    }

                                    if (result)

                                        break;

                                }

                                if (result)

                                    break;

                            }

                        }

                        _LMLabelPresist.Commit();

                    }

                    ReleaseCOMObjects(_TargetItem);

                    ReleaseCOMObjects(_LMLabelPresist);

                }

            }

            SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, ++CurrentCount);

        }

        /// <summary>

        /// Equipment를 실제로 Modeling 메서드

        /// </summary>

        /// <param name="equipment"></param>

        private void EquipmentModeling(Equipment equipment)

        {

            if (!string.IsNullOrEmpty(equipment.SPPID.RepresentationId))

                return;

            LMSymbol _LMSymbol = null;

            LMSymbol targetItem = null;

            string mappingPath = equipment.SPPID.MAPPINGNAME;

            double x = equipment.SPPID.ORIGINAL_X;

            double y = equipment.SPPID.ORIGINAL_Y;

            int mirror = 0;

            double angle = equipment.ANGLE;

            SPPIDUtil.ConvertGridPoint(ref x, ref y);

            Connector connector = equipment.CONNECTORS.Find(conn => !string.IsNullOrEmpty(conn.CONNECTEDITEM) && conn.CONNECTEDITEM != "None");

            if (connector != null)

            {

                Equipment connEquipment = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM) as Equipment;

                if (connEquipment != null)

                {

                    if (string.IsNullOrEmpty(connEquipment.SPPID.RepresentationId))

                        EquipmentModeling(connEquipment);

                    if (!string.IsNullOrEmpty(connEquipment.SPPID.RepresentationId))

                    {

                        targetItem = dataSource.GetSymbol(connEquipment.SPPID.RepresentationId);

                        if (targetItem != null)

                        {

                            _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle, TargetItem: targetItem);

                        }

                        else

                        {

                            _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

                        }

                    }

                    else

                    {

                        _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

                    }

                }

                else

                {

                    _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

                }

            }

            else

            {

                _LMSymbol = _placement.PIDPlaceSymbol(mappingPath, x, y, Mirror: mirror, Rotation: angle);

            }

            if (_LMSymbol != null)

            {

                _LMSymbol.Commit();

                equipment.SPPID.RepresentationId = _LMSymbol.AsLMRepresentation().Id;

                equipment.SPPID.GraphicOID = _LMSymbol.get_GraphicOID();

                ReleaseCOMObjects(_LMSymbol);

            }

            if (targetItem != null)

            {

                ReleaseCOMObjects(targetItem);

            }

            ReleaseCOMObjects(_LMSymbol);

            SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, ++CurrentCount);

        }

        /// <summary>

        /// 3개의 Symbol이 붙어있을경우 CenterSymbol을 Grid기준으로 맞추기 위해서 모델링

        /// </summary>

        /// <param name="group"></param>

        private void SymbolModelingByThreeSymbolGroup(List<Symbol> group)

        {

            // Group의 가운데 찾기

            Symbol symbol1 = null;

            Symbol symbol2 = null;

            Symbol centerSymbol = null;

            foreach (var symbol in group)

            {

                int count = 0;

                foreach (var connector in symbol.CONNECTORS)

                {

                    object item = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM);

                    if (item != null && item.GetType() == typeof(Symbol))

                        count++;

                }

                // Center Symbol

                if (count == 2)

                {

                    SymbolModeling(symbol, null);

                    centerSymbol = symbol;

                }

                else if (symbol1 == null)

                    symbol1 = symbol;

                else

                    symbol2 = symbol;

            }

            SymbolModeling(symbol1, centerSymbol);

            SymbolModeling(symbol2, centerSymbol);

        }

        /// <summary>

        /// 심볼을 실제로 Modeling할때 ChildSymbol이 있다면 Modeling하는 메서드

        /// </summary>

        /// <param name="childSymbol"></param>

        /// <param name="parentSymbol"></param>

        private void CreateChildSymbol(ChildSymbol childSymbol, LMSymbol parentSymbol)

        {

            Ingr.RAD2D.Symbol2d symbol2d = radApp.ActiveDocument.ActiveSheet.DrawingObjects[parentSymbol.get_GraphicOID().ToString()];

            double x1 = 0;

            double x2 = 0;

            double y1 = 0;

            double y2 = 0;

            symbol2d.Range(out x1, out y1, out x2, out y2);

            LMSymbol _LMSymbol = _placement.PIDPlaceSymbol(childSymbol.SPPID.MAPPINGNAME, (x1 + x2) / 2, (y1 + y2) / 2, TargetItem: parentSymbol);

            if (_LMSymbol != null)

            {

                childSymbol.SPPID.RepresentationId = _LMSymbol.AsLMRepresentation().Id;

                foreach (var item in childSymbol.ChildSymbols)

                    CreateChildSymbol(item, _LMSymbol);

            }

            ReleaseCOMObjects(_LMSymbol);

        }

        /// <summary>

        /// item이 TargetItem과 같은 LineRun에 있는지 검사

        /// </summary>

        /// <param name="item"></param>

        /// <param name="targetItem"></param>

        /// <returns></returns>

        private bool IsSameLineRun(object item, object targetItem)

        {

            foreach (var lineNumber in document.LINENUMBERS)

            {

                foreach (var run in lineNumber.RUNS)

                {

                    foreach (var runItem in run.RUNITEMS)

                    {

                        if (runItem == item)

                        {

                            foreach (var findItem in run.RUNITEMS)

                            {

                                if (findItem == targetItem)

                                {

                                    return true;

                                }

                            }

                            return false;

                        }

                    }

                }

            }

            return false;

        }

        /// <summary>

        /// Line을 실제로 모델링하는 메서드

        /// </summary>

        /// <param name="lines"></param>

        private void LineModeling(List<Line> lines)

        {

            _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            LMSymbol _LMSymbol1 = null;

            LMSymbol _LMSymbol2 = null;

            Dictionary<LMConnector, List<double[]>> connectorVertices1 = new Dictionary<LMConnector, List<double[]>>();

            LMConnector targetConnector1 = null;

            Dictionary<LMConnector, List<double[]>> connectorVertices2 = new Dictionary<LMConnector, List<double[]>>();

            LMConnector targetConnector2 = null;

            Line startBranchLine = null;

            Line endBranchLine = null;

            // Type, Line, TargetObjet, x, y

            List<Tuple<string, Line, object, double, double>> linePointInfo = new List<Tuple<string, Line, object, double, double>>();

            // Point 정리

            for (int i = 0; i < lines.Count; i++)

            {

                Line line = lines[i];

                if (i == 0 || i + 1 != lines.Count)

                {

                    // 시작점에 연결된 Symbol 찾기

                    object connItem = SPPIDUtil.FindObjectByUID(document, line.CONNECTORS[0].CONNECTEDITEM);

                    if (connItem != null && connItem.GetType() == typeof(Symbol))

                    {

                        Symbol symbol1 = connItem as Symbol;

                        _LMSymbol1 = GetTargetSymbol(symbol1, line);

                        if (_LMSymbol1 != null)

                        {

                            double x = line.SPPID.START_X;

                            double y = line.SPPID.START_Y;

                            Connector connector = SPPIDUtil.FindSymbolConnectorByUID(document, line.UID, symbol1);

                            if (connector != null)

                            {

                                GetTargetSymbolConnectorPoint(connector, symbol1, ref x, ref y);

                                line.SPPID.START_X = x;

                                line.SPPID.START_Y = y;

                            }

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>("SYMBOL", line, _LMSymbol1, x, y));

                        }

                        else

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.START_X, line.SPPID.START_Y));

                    }

                    else if (connItem != null && connItem.GetType() == typeof(Line) && !lines.Contains(connItem))

                    {

                        connectorVertices1 = GetPipeRunVertices(((Line)connItem).SPPID.ModelItemId);

                        targetConnector1 = FindTargetLMConnector(connectorVertices1, line.SPPID.START_X, line.SPPID.START_Y, line.SPPID.END_X, line.SPPID.END_Y);

                        if (targetConnector1 != null)

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>("LINE", line, targetConnector1, line.SPPID.START_X, line.SPPID.START_Y));

                        else

                        {

                            startBranchLine = connItem as Line;

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.START_X, line.SPPID.START_Y));

                        }

                    }

                    else

                        linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.START_X, line.SPPID.START_Y));

                }

                if (i + 1 == lines.Count)

                {

                    // 끝점에 연결된 Symbol 찾기

                    object connItem = SPPIDUtil.FindObjectByUID(document, line.CONNECTORS[1].CONNECTEDITEM);

                    if (i != 0)

                        linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.START_X, line.SPPID.START_Y));

                    if (connItem != null && connItem.GetType() == typeof(Symbol))

                    {

                        Symbol symbol2 = connItem as Symbol;

                        _LMSymbol2 = GetTargetSymbol(connItem as Symbol, line);

                        if (_LMSymbol2 != null)

                        {

                            double x = line.SPPID.END_X;

                            double y = line.SPPID.END_Y;

                            Connector connector = SPPIDUtil.FindSymbolConnectorByUID(document, line.UID, symbol2);

                            if (connector != null)

                            {

                                GetTargetSymbolConnectorPoint(connector, symbol2, ref x, ref y);

                                line.SPPID.END_X = x;

                                line.SPPID.END_Y = y;

                            }

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>("SYMBOL", line, _LMSymbol2, x, y));

                        }

                        else

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.END_X, line.SPPID.END_Y));

                    }

                    else if (connItem != null && connItem.GetType() == typeof(Line) && !lines.Contains(connItem))

                    {

                        connectorVertices2 = GetPipeRunVertices(((Line)connItem).SPPID.ModelItemId);

                        targetConnector2 = FindTargetLMConnector(connectorVertices2, line.SPPID.END_X, line.SPPID.END_Y, line.SPPID.START_X, line.SPPID.START_Y);

                        if (targetConnector2 != null)

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>("LINE", line, targetConnector2, line.SPPID.END_X, line.SPPID.END_Y));

                        else

                        {

                            endBranchLine = connItem as Line;

                            linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.END_X, line.SPPID.END_Y));

                        }

                    }

                    else

                        linePointInfo.Add(new Tuple<string, Line, object, double, double>(null, line, null, line.SPPID.END_X, line.SPPID.END_Y));

                }

            }

            double prevX = double.NaN;

            double prevY = double.NaN;

            SlopeType prevSlopeType = SlopeType.None;

            for (int i = 0; i < linePointInfo.Count; i++)

            {

                Tuple<string, Line, object, double, double> item = linePointInfo[i];

                Line line = item.Item2;

                double x = item.Item4;

                double y = item.Item5;

                SlopeType slopeType = SPPIDUtil.CalcSlope(line.SPPID.START_X, line.SPPID.START_Y, line.SPPID.END_X, line.SPPID.END_Y);

                // Symbol일 경우 바로 Input Point

                if (item.Item1 == "SYMBOL")

                {

                    placeRunInputs.AddSymbolTarget(item.Item3 as LMSymbol, x, y);

                    prevX = x;

                    prevY = y;

                    prevSlopeType = slopeType;

                    continue;

                }

                SPPIDUtil.ConvertGridPoint(ref x, ref y);

                // i == 0은 그대로 사용

                if (i != 0)

                {

                    Tuple<string, Line, object, double, double> prevItem = linePointInfo[i - 1];

                    // y 좌표가 같아야함

                    if (prevSlopeType == SlopeType.HORIZONTAL)

                        y = prevY;

                    else if (prevSlopeType == SlopeType.VERTICAL)

                        x = prevX;

                    if (i + 1 == linePointInfo.Count - 1 && linePointInfo[i + 1].Item1 == "SYMBOL")

                    {

                        Line nextLine = linePointInfo[i + 1].Item2;

                        SlopeType nextSlopeType = SPPIDUtil.CalcSlope(nextLine.SPPID.START_X, nextLine.SPPID.START_Y, nextLine.SPPID.END_X, nextLine.SPPID.END_Y);

                        if (prevSlopeType == SlopeType.HORIZONTAL)

                            y = linePointInfo[i + 1].Item5;

                        else if (prevSlopeType == SlopeType.VERTICAL)

                            x = linePointInfo[i + 1].Item4;

                    }

                }

                if (item.Item1 == "LINE")

                    placeRunInputs.AddConnectorTarget(item.Item3 as LMConnector, x, y);

                else

                    placeRunInputs.AddPoint(x, y);

                prevX = x;

                prevY = y;

                prevSlopeType = slopeType;

            }

            LMConnector _lMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

            if (_lMConnector != null)

            {

                foreach (var line in lines)

                    line.SPPID.ModelItemId = _lMConnector.ModelItemID;

                _lMConnector.Commit();

                if (startBranchLine != null || endBranchLine != null)

                {

                    BranchLines.Add(new Tuple<string, Line, Line>(_lMConnector.ModelItemID, startBranchLine, endBranchLine));

                }

            }

            if (_LMSymbol1 != null)

                ReleaseCOMObjects(_LMSymbol1);

            if (_LMSymbol2 != null)

                ReleaseCOMObjects(_LMSymbol2);

            if (targetConnector1 != null)

                ReleaseCOMObjects(targetConnector1);

            if (targetConnector2 != null)

                ReleaseCOMObjects(targetConnector2);

            foreach (var item in connectorVertices1)

                ReleaseCOMObjects(item.Key);

            foreach (var item in connectorVertices2)

                ReleaseCOMObjects(item.Key);

            ReleaseCOMObjects(_lMConnector);

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

        }

        /// <summary>

        /// Symbol이 모델링된 SPPPID Symbol Object를 반환 - 연결된 Symbol이 ChildSymbol일 수도 있기때문에 메서드 개발

        /// </summary>

        /// <param name="symbol"></param>

        /// <param name="line"></param>

        /// <returns></returns>

        private LMSymbol GetTargetSymbol(Symbol symbol, Line line)

        {

            LMSymbol _LMSymbol = null;

            foreach (var connector in symbol.CONNECTORS)

            {

                if (connector.CONNECTEDITEM == line.UID)

                {

                    if (connector.Index == 0)

                        _LMSymbol = dataSource.GetSymbol(symbol.SPPID.RepresentationId);

                    else

                    {

                        ChildSymbol child = null;

                        foreach (var childSymbol in symbol.ChildSymbols)

                        {

                            if (childSymbol.Connectors.Contains(connector))

                                child = childSymbol;

                            else

                                child = GetChildSymbolByConnector(childSymbol, connector);

                            if (child != null)

                                break;

                        }

                        if (child != null)

                            _LMSymbol = dataSource.GetSymbol(child.SPPID.RepresentationId);

                    }

                    break;  

                }

            }

            return _LMSymbol;

        }

        /// <summary>

        /// Connector를 가지고 있는 ChildSymbol Object 반환

        /// </summary>

        /// <param name="item"></param>

        /// <param name="connector"></param>

        /// <returns></returns>

        private ChildSymbol GetChildSymbolByConnector(ChildSymbol item, Connector connector)

        {

            foreach (var childSymbol in item.ChildSymbols)

            {

                if (childSymbol.Connectors.Contains(connector))

                    return childSymbol;

                else

                    return GetChildSymbolByConnector(childSymbol, connector);

            }

            return null;

        }

        /// <summary>

        /// Branch 라인을 다시 모델링하는 진입 메서드

        /// </summary>

        /// <param name="branch"></param>

        private void BranchLineModeling(Tuple<string, Line, Line> branch)

        {

            List<Line> lines = SPPIDUtil.FindLinesByModelId(document, branch.Item1);

            Dictionary<LMConnector, List<double[]>> connectorVertices = GetPipeRunVertices(branch.Item1);

            LMConnector _StartConnector = null;

            LMConnector _EndConnector = null;

            double lengthStart = double.MaxValue;

            double lengthEnd = double.MaxValue;

            List<double[]> startPoints = new List<double[]>();

            List<double[]> endPoints = new List<double[]>();

            foreach (var item in connectorVertices)

            {

                foreach (var point in item.Value)

                {

                    // Start Point가 Branch

                    if (branch.Item2 != null)

                    {

                        Line targetLine = branch.Item2;

                        double distance = SPPIDUtil.CalcLineToPointDistance(targetLine.SPPID.START_X, targetLine.SPPID.START_Y, targetLine.SPPID.END_X, targetLine.SPPID.END_Y, point[0], point[1]);

                        if (lengthStart > distance)

                        {

                            _StartConnector = item.Key;

                            lengthStart = distance;

                            startPoints = item.Value;

                        }

                    }

                    // End Point가 Branch

                    if (branch.Item3 != null)

                    {

                        Line targetLine = branch.Item3;

                        double distance = SPPIDUtil.CalcLineToPointDistance(targetLine.SPPID.START_X, targetLine.SPPID.START_Y, targetLine.SPPID.END_X, targetLine.SPPID.END_Y, point[0], point[1]);

                        if (lengthEnd > distance)

                        {

                            _EndConnector = item.Key;

                            lengthEnd = distance;

                            endPoints = item.Value;

                        }

                    }

                }

            }

            #region Branch가 양쪽 전부일 때

            if (_StartConnector != null && _StartConnector == _EndConnector)

            {

                _placement.PIDRemovePlacement(_StartConnector.AsLMRepresentation());

                _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

                PlaceRunInputs placeRunInputs = new PlaceRunInputs();

                Dictionary<LMConnector, List<double[]>> startConnectorVertices = GetPipeRunVertices(branch.Item2.SPPID.ModelItemId);

                LMConnector _StartTargetConnector = FindTargetLMConnector(startConnectorVertices, startPoints[0][0], startPoints[0][1], startPoints[1][0], startPoints[1][1]);

                Dictionary<LMConnector, List<double[]>> endConnectorVertices = GetPipeRunVertices(branch.Item3.SPPID.ModelItemId);

                LMConnector _EndTargetConnector = FindTargetLMConnector(endConnectorVertices,

                   startPoints[startPoints.Count - 1][0],

                   startPoints[startPoints.Count - 1][1],

                   startPoints[startPoints.Count - 2][0],

                   startPoints[startPoints.Count - 2][1]);

                for (int i = 0; i < startPoints.Count; i++)

                {

                    double[] point = startPoints[i];

                    if (i == 0)

                        placeRunInputs.AddConnectorTarget(_StartTargetConnector, point[0], point[1]);

                    else if (i == startPoints.Count - 1)

                        placeRunInputs.AddConnectorTarget(_EndTargetConnector, point[0], point[1]);

                    else

                        placeRunInputs.AddPoint(point[0], point[1]);

                }

                LMConnector _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

                if (_LMConnector != null)

                {

                    _LMConnector.Commit();

                    foreach (var item in lines)

                        item.SPPID.ModelItemId = _LMConnector.ModelItemID;

                }

                foreach (var item in startConnectorVertices)

                    ReleaseCOMObjects(item.Key);

                foreach (var item in endConnectorVertices)

                    ReleaseCOMObjects(item.Key);

                ReleaseCOMObjects(placeRunInputs);

                ReleaseCOMObjects(_LMAItem);

                ReleaseCOMObjects(_LMConnector);

            }

            #endregion

            #region 양쪽이 다른 Branch 

            else

            {

                // Branch 시작 Connector

                if (_StartConnector != null)

                    BranchLineModelingByConnector(branch, _StartConnector, startPoints, true);

                // Branch 끝 Connector

                if (_EndConnector != null)

                    BranchLineModelingByConnector(branch, _EndConnector, endPoints, false);

            }

            #endregion

            if (_StartConnector != null)

                ReleaseCOMObjects(_StartConnector);

            if (_EndConnector != null)

                ReleaseCOMObjects(_EndConnector);

            foreach (var item in connectorVertices)

                ReleaseCOMObjects(item.Key);

        }

        /// <summary>

        /// Branch 라인을 다시 실제로 모델링하는 메서드

        /// </summary>

        /// <param name="branch"></param>

        /// <param name="_Connector"></param>

        /// <param name="points"></param>

        /// <param name="IsStart"></param>

        private void BranchLineModelingByConnector(Tuple<string, Line, Line> branch, LMConnector _Connector, List<double[]> points, bool IsStart)

        {

            List<Line> lines = SPPIDUtil.FindLinesByModelId(document, branch.Item1);

            Dictionary<LMConnector, List<double[]>> connectorVertices = GetPipeRunVertices(branch.Item1);

            LMConnector _SameRunTargetConnector = null;

            LMSymbol _SameRunTargetSymbol = null;

            Dictionary<LMConnector, List<double[]>> branchConnectorVertices = null;

            LMConnector _BranchTargetConnector = null;

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            // 같은 Line Run의 Connector 찾기

            foreach (var item in connectorVertices)

            {

                if (item.Key == _Connector)

                    continue;

                if (IsStart &&

                    !DBNull.Value.Equals(item.Key.ConnectItem1SymbolID) &&

                    !DBNull.Value.Equals(_Connector.ConnectItem2SymbolID)&& 

                    item.Key.ConnectItem1SymbolID == _Connector.ConnectItem2SymbolID)

                {

                    _SameRunTargetConnector = item.Key;

                    break;

                }

                else if (!IsStart &&

                    !DBNull.Value.Equals(item.Key.ConnectItem2SymbolID) &&

                    !DBNull.Value.Equals(_Connector.ConnectItem1SymbolID) && 

                    item.Key.ConnectItem2SymbolID == _Connector.ConnectItem1SymbolID)

                {

                    _SameRunTargetConnector = item.Key;

                    break;

                }

            }

            // Branch 반대편이 Symbol

            if (_SameRunTargetConnector == null)

            {

                foreach (var line in lines)

                {

                    foreach (var connector in line.CONNECTORS)

                    {

                        Symbol symbol = SPPIDUtil.FindObjectByUID(document, connector.CONNECTEDITEM) as Symbol;

                        if (symbol != null)

                        {

                            _SameRunTargetSymbol = dataSource.GetSymbol(symbol.SPPID.RepresentationId);

                            break;

                        }

                    }

                }

            }

            // 기존 Connector 제거

            _placement.PIDRemovePlacement(_Connector.AsLMRepresentation());

            // 시작 Connector일 경우 첫 Point가 TargetConnector를 찾아야함

            if (IsStart)

            {

                branchConnectorVertices = GetPipeRunVertices(branch.Item2.SPPID.ModelItemId);

                _BranchTargetConnector = FindTargetLMConnector(branchConnectorVertices, points[0][0], points[0][1], points[1][0], points[1][1]);

            }

            // 끝 Conenctor일 경우 마지막 Point가 TargetConnector를 찾아야함

            else

            {

                branchConnectorVertices = GetPipeRunVertices(branch.Item3.SPPID.ModelItemId);

                _BranchTargetConnector = FindTargetLMConnector(branchConnectorVertices,

                    points[points.Count - 1][0],

                    points[points.Count - 1][1],

                    points[points.Count - 2][0],

                    points[points.Count - 2][1]);

            }

            for (int i = 0; i < points.Count; i++)

            {

                double[] point = points[i];

                if (i == 0)

                {

                    if (IsStart)

                    {

                        if (_BranchTargetConnector != null)

                        {

                            placeRunInputs.AddConnectorTarget(_BranchTargetConnector, point[0], point[1]);

                        }

                        else

                        {

                            placeRunInputs.AddPoint(point[0], point[1]);

                        }

                    }

                    else

                    {

                        if (_SameRunTargetConnector != null)

                            placeRunInputs.AddConnectorTarget(_SameRunTargetConnector, point[0], point[1]);

                        else if (_SameRunTargetSymbol != null)

                            placeRunInputs.AddSymbolTarget(_SameRunTargetSymbol, point[0], point[1]);

                        else

                            placeRunInputs.AddPoint(point[0], point[1]);

                    }

                }

                else if (i == points.Count - 1)

                {

                    if (IsStart)

                    {

                        if (_SameRunTargetConnector != null)

                            placeRunInputs.AddConnectorTarget(_SameRunTargetConnector, point[0], point[1]);

                        else if (_SameRunTargetSymbol != null)

                            placeRunInputs.AddSymbolTarget(_SameRunTargetSymbol, point[0], point[1]);

                        else

                            placeRunInputs.AddPoint(point[0], point[1]);

                    }

                    else

                    {

                        if (_BranchTargetConnector != null)

                        {

                            placeRunInputs.AddConnectorTarget(_BranchTargetConnector, point[0], point[1]);

                        }

                        else

                        {

                            placeRunInputs.AddPoint(point[0], point[1]);

                        }

                    }

                }

                else

                    placeRunInputs.AddPoint(point[0], point[1]);

            }

            _LMAItem _LMAItem = _placement.PIDCreateItem(lines[0].SPPID.MAPPINGNAME);

            LMConnector _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

            if (_LMConnector != null)

            {

                if (_SameRunTargetConnector != null)

                {

                    JoinPipeRun(_LMConnector.ModelItemID, _SameRunTargetConnector.ModelItemID);

                }

                else

                {

                    foreach (var item in lines)

                        item.SPPID.ModelItemId = _LMConnector.ModelItemID;

                }

                _LMConnector.Commit();

                ReleaseCOMObjects(_LMConnector);

            }

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

            if (_BranchTargetConnector != null)

                ReleaseCOMObjects(_BranchTargetConnector);

            if (_SameRunTargetConnector != null)

                ReleaseCOMObjects(_SameRunTargetConnector);

            if (_SameRunTargetSymbol != null)

                ReleaseCOMObjects(_SameRunTargetSymbol);

            foreach (var item in connectorVertices)

                ReleaseCOMObjects(item.Key);

            foreach (var item in branchConnectorVertices)

                ReleaseCOMObjects(item.Key);

        }

        /// <summary>

        /// EndBreak 모델링 메서드

        /// </summary>

        /// <param name="endBreak"></param>

        private void EndBreakModeling(EndBreak endBreak)

        {

            object ownerObj = SPPIDUtil.FindObjectByUID(document, endBreak.OWNER);

            LMConnector targetLMConnector = null;

            if (ownerObj !=null && ownerObj.GetType() == typeof(Line))

            {

                Line ownerLine = ownerObj as Line;

                LMLabelPersist _LmLabelPersist = null;

                Dictionary<LMConnector, List<double[]>> connectorVertices = GetPipeRunVertices(ownerLine.SPPID.ModelItemId);

                targetLMConnector = FindTargetLMConnectorByPoint(connectorVertices, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y);

                if (targetLMConnector != null)

                {

                    Array array = new double[] { 0, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y };

                    _LmLabelPersist = _placement.PIDPlaceLabel(endBreak.SPPID.MAPPINGNAME, ref array, Rotation: 0, LabeledItem: targetLMConnector.AsLMRepresentation(), IsLeaderVisible: true);

                }

                if (_LmLabelPersist != null)

                {

                    _LmLabelPersist.Commit();

                    ReleaseCOMObjects(_LmLabelPersist);

                }

                else

                    RetryEndBreakModeling(endBreak, targetLMConnector);

                foreach (var item in connectorVertices)

                    ReleaseCOMObjects(item.Key);

            }

            else if (ownerObj != null && ownerObj.GetType() == typeof(Symbol))

            {

                Symbol ownerSymbol = ownerObj as Symbol;

                LMSymbol _LMSymbol = dataSource.GetSymbol(ownerSymbol.SPPID.RepresentationId);

                targetLMConnector = null;

                double distance = double.MaxValue;

                foreach (LMConnector connector in _LMSymbol.Avoid1Connectors)

                {

                    if (connector.get_ItemStatus() == "Active")

                    {

                        dynamic OID = connector.get_GraphicOID();

                        DependencyObject drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID];

                        Ingr.RAD2D.LineStringGeometry2d lineStringGeometry = drawingObject.GetGeometry() as Ingr.RAD2D.LineStringGeometry2d;

                        int verticesCount = lineStringGeometry.VertexCount;

                        double[] vertices = null;

                        lineStringGeometry.GetVertices(ref verticesCount, ref vertices);

                        for (int i = 0; i < verticesCount; i++)

                        {

                            double x = 0;

                            double y = 0;

                            lineStringGeometry.GetVertex(i + 1, ref x, ref y);

                            double result = SPPIDUtil.CalcPointToPointdDistance(x, y, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y);

                            if (result < distance)

                            {

                                targetLMConnector = connector;

                                distance = result;

                            }

                        }

                    }

                }

                foreach (LMConnector connector in _LMSymbol.Avoid2Connectors)

                {

                    if (connector.get_ItemStatus() == "Active")

                    {

                        dynamic OID = connector.get_GraphicOID();

                        DependencyObject drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID];

                        Ingr.RAD2D.LineStringGeometry2d lineStringGeometry = drawingObject.GetGeometry() as Ingr.RAD2D.LineStringGeometry2d;

                        int verticesCount = lineStringGeometry.VertexCount;

                        double[] vertices = null;

                        lineStringGeometry.GetVertices(ref verticesCount, ref vertices);

                        for (int i = 0; i < verticesCount; i++)

                        {

                            double x = 0;

                            double y = 0;

                            lineStringGeometry.GetVertex(i + 1, ref x, ref y);

                            double result = SPPIDUtil.CalcPointToPointdDistance(x, y, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y);

                            if (result < distance)

                            {

                                targetLMConnector = connector;

                                distance = result;

                            }

                        }

                    }

                }

                if (targetLMConnector != null)

                {

                    LMLabelPersist _LmLabelPersist = null;

                    Array array = new double[] { 0, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y };

                    _LmLabelPersist = _placement.PIDPlaceLabel(endBreak.SPPID.MAPPINGNAME, ref array, Rotation: 0, LabeledItem: targetLMConnector.AsLMRepresentation(), IsLeaderVisible: true);

                    if (_LmLabelPersist != null)

                    {

                        _LmLabelPersist.Commit();

                        ReleaseCOMObjects(_LmLabelPersist);

                    }

                    else

                        RetryEndBreakModeling(endBreak, targetLMConnector);

                }

                ReleaseCOMObjects(_LMSymbol);

            }

            SplashScreenManager.Default.SendCommand(SPPIDSplashScreen.SplashScreenCommand.SetProgress, ++CurrentCount);

        }

        /// <summary>

        /// EndBreak 모델링이 실패시 다시 시도하는 메서드

        /// </summary>

        /// <param name="endBreak"></param>

        /// <param name="targetLMConnector"></param>

        private void RetryEndBreakModeling(EndBreak endBreak, LMConnector targetLMConnector)

        {

            bool isZeroLength = Convert.ToBoolean(targetLMConnector.get_IsZeroLength());

            Array array = null;

            LMLabelPersist _LMLabelPersist = null;

            LMConnector _LMConnector = null;

            dynamic OID = targetLMConnector.get_GraphicOID();

            DependencyObject drawingObject = radApp.ActiveDocument.ActiveSheet.DrawingObjects[OID];

            Ingr.RAD2D.LineStringGeometry2d lineStringGeometry = drawingObject.GetGeometry() as Ingr.RAD2D.LineStringGeometry2d;

            int verticesCount = lineStringGeometry.VertexCount;

            PlaceRunInputs placeRunInputs = new PlaceRunInputs();

            _LMAItem _LMAItem = _placement.PIDCreateItem(@"\Piping\Routing\Process Lines\Primary Piping.sym");

            if (isZeroLength)

            {

                double[] vertices = null;

                lineStringGeometry.GetVertices(ref verticesCount, ref vertices);

                double x = 0;

                double y = 0;

                lineStringGeometry.GetVertex(1, ref x, ref y);

                placeRunInputs.AddSymbolTarget(targetLMConnector.ConnectItem1SymbolObject, x, y);

                placeRunInputs.AddSymbolTarget(targetLMConnector.ConnectItem2SymbolObject, x, y);

                _placement.PIDRemovePlacement(targetLMConnector.AsLMRepresentation());

                _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

                array = new double[] { 0, x, y };

                _LMLabelPersist = _placement.PIDPlaceLabel(endBreak.SPPID.MAPPINGNAME, ref array, Rotation: 0, LabeledItem: _LMConnector.AsLMRepresentation(), IsLeaderVisible: true);

                AutoJoinPipeRun(_LMConnector.ModelItemID);

            }

            else

            {

                List<double[]> vertices = new List<double[]>();

                for (int i = 1; i <= verticesCount; i++)

                {

                    double x = 0;

                    double y = 0;

                    lineStringGeometry.GetVertex(i, ref x, ref y);

                    vertices.Add(new double[] { x, y });

                }

                for (int i = 0; i < vertices.Count; i++)

                {

                    double[] points = vertices[i];

                    if (i == 0)

                    {

                        if (targetLMConnector.ConnectItem1SymbolObject != null)

                            placeRunInputs.AddSymbolTarget(targetLMConnector.ConnectItem1SymbolObject, points[0], points[1]);

                        else

                            placeRunInputs.AddPoint(points[0], points[1]);

                    }

                    else if (i == vertices.Count - 1)

                    {

                        if (targetLMConnector.ConnectItem2SymbolObject != null)

                            placeRunInputs.AddSymbolTarget(targetLMConnector.ConnectItem2SymbolObject, points[0], points[1]);

                        else

                            placeRunInputs.AddPoint(points[0], points[1]);

                    }

                    else

                        placeRunInputs.AddPoint(points[0], points[1]);

                }

                List<Line> lines = SPPIDUtil.FindLinesByModelId(document, targetLMConnector.ModelItemID);

                _placement.PIDRemovePlacement(targetLMConnector.AsLMRepresentation());

                _LMConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

                array = new double[] { 0, endBreak.SPPID.ORIGINAL_X, endBreak.SPPID.ORIGINAL_Y };

                _LMLabelPersist = _placement.PIDPlaceLabel(endBreak.SPPID.MAPPINGNAME, ref array, Rotation: 0, LabeledItem: _LMConnector.AsLMRepresentation(), IsLeaderVisible: true);

                AutoJoinPipeRun(_LMConnector.ModelItemID);

                foreach (var line in lines)

                    line.SPPID.ModelItemId = _LMConnector.ModelItemID;

            }

            if (_LMLabelPersist != null)

            {

                _LMLabelPersist.Commit();

                ReleaseCOMObjects(_LMLabelPersist);

            }

            else

            {

            }

            ReleaseCOMObjects(_LMConnector);

            ReleaseCOMObjects(placeRunInputs);