HYTOS

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Data;

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;

        }

        private void SetSystemEditingCommand(bool value)

        {

            foreach (var item in radApp.Commands)

            {

                if (item.Argument == "SystemEditingCmd.SystemEditing")

                {

                    if (item.Checked != value)

                    {

                        radApp.RunMacro("systemeditingcmd.dll");

                        break;

                    }

                }

            }

        }

        /// <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);

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

                    List<Symbol> prioritySymbols = GetPrioritySymbol();

                    foreach (var item in prioritySymbols)

                        SymbolModelingByPriority(item);

                    // 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);

                    // SpecBreak Modeling

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

                    foreach (var item in document.SpecBreaks)

                        SpecBreakModeling(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 LineNumbers 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);

                    // Input SpecBreak Attribute

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

                    foreach (var item in document.SpecBreaks)

                        InputSpecBreakAttribute(item);

                    // Label Symbol Modeling

                    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 (radApp.ActiveDocument != null)

                {

                    //radApp.ActiveDocument.Save();

                    //radApp.ActiveDocument.SaveOnClose = false;

                    //radApp.ActiveDocument.Close(false);

                    ReleaseCOMObjects(newDrawing);

                }

                ReleaseCOMObjects(dataSource);

                ReleaseCOMObjects(_placement);

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

                SplashScreenManager.CloseForm(false);

            }

        }

        /// <summary>

        /// 도면 생성 메서드

        /// </summary>

        private void CreateDocument()

        {

            string drawingName = document.DrawingName;

            string drawingNumber = document.DrawingNumber;

            GetDrawingNameAndNumber(ref drawingName, ref drawingNumber);

            newDrawing = application.Drawings.Add(document.Unit, document.Template, drawingNumber, drawingName);

            application.ActiveWindow.Fit();

            Thread.Sleep(1000);

            application.ActiveWindow.Zoom = 2000;

            Thread.Sleep(2000);

            Project_DB.InsertDrawingInfo(document.PATH, drawingNumber, drawingName);

        }

        /// <summary>

        /// DrawingName, DrawingNumber를 확인하여 중복이 있으면 _1을 붙이고 +1씩 한다.

        /// </summary>

        /// <param name="drawingName"></param>

        /// <param name="drawingNumber"></param>

        private void GetDrawingNameAndNumber(ref string drawingName, ref string drawingNumber)

        {

            LMDrawings drawings = new LMDrawings();

            drawings.Collect(dataSource);

            List<string> drawingNameList = new List<string>();

            List<string> drawingNumberList = new List<string>();

            foreach (LMDrawing item in drawings)

            {

                drawingNameList.Add(item.Attributes["Name"].get_Value().ToString());

                drawingNumberList.Add(item.Attributes["DrawingNumber"].get_Value().ToString());

            }

            int nameLength = drawingName.Length;

            while (drawingNameList.Contains(drawingName))

            {

                if (nameLength == drawingName.Length)

                    drawingName += "-1";

                else

                {

                    int index = Convert.ToInt32(drawingName.Remove(0, nameLength + 1));

                    drawingName = drawingName.Substring(0, nameLength + 1);

                    drawingName += ++index;

                }

            }

            int numberLength = drawingNumber.Length;

            while (drawingNameList.Contains(drawingNumber))

            {

                if (numberLength == drawingNumber.Length)

                    drawingNumber += "-1";

                else

                {

                    int index = Convert.ToInt32(drawingNumber.Remove(0, numberLength + 1));

                    drawingNumber = drawingNumber.Substring(0, numberLength + 1);

                    drawingNumber += ++index;

                }

            }

            ReleaseCOMObjects(drawings);

        }

        /// <summary>

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

        /// </summary>

        /// <returns></returns>

        private bool DocumentCoordinateCorrection()

        {

            if (Settings.Default.DrawingX != 0 && Settings.Default.DrawingY != 0)

            {

                document.SetSPPIDLocation(Settings.Default.DrawingX, Settings.Default.DrawingY);

                document.CoordinateCorrection();

                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)

        {

#if DEBUG

            try

            {

#endif

                // 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;

                // Mirror 계산

                if (symbol.FLIP == 1)

                {

                    mirror = 1;

                    angle += Math.PI;

                }

                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);

                    if (_LMSymbol != null && _TargetItem != null)

                    {

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

                        LMConnector reModelingConnector = FindBreakLineTarget(symbol, targetSymbol);

                        if (reModelingConnector != null)

                            ReModelingLMConnector(reModelingConnector);

                    }

                    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);

#if DEBUG

            }

            catch (Exception ex)

            {

                System.Windows.Forms.MessageBox.Show(ex.StackTrace);

            }

#endif

        }

        /// <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);

        }

        private void SymbolModelingByPriority(Symbol symbol)

        {

            // Angle, Center, 우선순위 모델링

            SymbolModeling(symbol, null);

            List<Symbol> group = new List<Symbol>() { symbol };

            SPPIDUtil.FindConnectedSymbolGroup(document, symbol, group);

            List<Symbol> endModeling = new List<Symbol>() { symbol };

            while (endModeling.Count != group.Count)

            {

                foreach (var item in group)

                {

                    if (!endModeling.Contains(item))

                    {

                        bool result = false;

                        foreach (var connector in item.CONNECTORS)

                        {

                            Symbol connSymbol = group.Find(x => x.UID == connector.CONNECTEDITEM);

                            if (connSymbol == item)

                                throw new Exception(connSymbol.UID);

                            if (connSymbol != null && endModeling.Contains(connSymbol))

                            {

                                SymbolModeling(item, connSymbol);

                                endModeling.Add(item);

                                result = true;

                                break;

                            }

                        }

                        if (result)

                            break;

                    }

                }

            }

        }

        /// <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);

                else

                {

                    SPPIDUtil.ConvertGridPoint(ref x, ref y);

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

                    if (i != 0)

                    {

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

                        // y 좌표가 같아야함 및 Symbol 좌표가 정확하지 않으므로 한번더 보정

                        if (prevSlopeType == SlopeType.HORIZONTAL)

                        {

                            y = prevY;

                            SPPIDUtil.ConvertGridPointOnlyOnePoint(ref y);

                        }

                        else if (prevSlopeType == SlopeType.VERTICAL)

                        {

                            x = prevX;

                            SPPIDUtil.ConvertGridPointOnlyOnePoint(ref x);

                        }

                        // 마지막이 Symbol일 경우는 Symbol의 좌표를 따라감

                        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 (slopeType == SlopeType.HORIZONTAL)

                                y = linePointInfo[i + 1].Item5;

                            else if (slopeType == 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)

            {

                if (_LMSymbol1 != null || _LMSymbol2 != null)

                    ReModelingLine(lines, _lMConnector, _LMSymbol1, _LMSymbol2);

                else

                {

                    foreach (var line in lines)

                        line.SPPID.ModelItemId = _lMConnector.ModelItemID;

                    _lMConnector.Commit();

                }

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

                    BranchLines.Add(new Tuple<string, Line, Line>(lines[0].SPPID.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에 붙을 경우 Line을 Remodeling 한다.

        /// </summary>

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

        /// <param name="prevLMConnector"></param>

        /// <param name="startSymbol"></param>

        /// <param name="endSymbol"></param>

        private void ReModelingLine(List<Line> lines, LMConnector prevLMConnector, LMSymbol startSymbol, LMSymbol endSymbol)

        {

            string symbolPath = string.Empty;

            #region get symbol path

            LMModelItem modelItem = dataSource.GetModelItem(prevLMConnector.ModelItemID);

            foreach (LMRepresentation rep in modelItem.Representations)

            {

                if (!DBNull.Value.Equals(rep.get_FileName()) && !string.IsNullOrEmpty(rep.get_FileName()))

                {

                    symbolPath = rep.get_FileName();

                    break;

                }

            }

            #endregion

            _LMAItem _LMAItem = _placement.PIDCreateItem(symbolPath);

            LMConnector newConnector = null;

            dynamic OID = prevLMConnector.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();

            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 (startSymbol != null && i == 0)

                {

                    SlopeType slopeType = SPPIDUtil.CalcSlope(points[0], points[1], vertices[i + 1][0], vertices[i + 1][1]);

                    if (slopeType == SlopeType.HORIZONTAL)

                        placeRunInputs.AddPoint(points[0], -0.1);

                    else if (slopeType == SlopeType.VERTICAL)

                        placeRunInputs.AddPoint(-0.1, points[1]);

                    else

                        placeRunInputs.AddPoint(points[0], -0.1);

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

                }

                // 마지막 심볼이 있고 마지막 좌표일 때

                else if (endSymbol != null && i == vertices.Count - 1)

                {

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

                    SlopeType slopeType = SPPIDUtil.CalcSlope(points[0], points[1], vertices[i - 1][0], vertices[i - 1][1]);

                    if (slopeType == SlopeType.HORIZONTAL)

                        placeRunInputs.AddPoint(points[0], -0.1);

                    else if (slopeType == SlopeType.VERTICAL)

                        placeRunInputs.AddPoint(-0.1, points[1]);

                    else

                        placeRunInputs.AddPoint(points[0], -0.1);

                }

                // 첫번째이며 시작 심볼이 아니고 Connecotr일 경우

                else if (i == 0 && prevLMConnector.ConnectItem1SymbolObject != null)

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

                // 마지막이며 마지막 심볼이 아니고 Connecotr일 경우

                else if (i == vertices.Count - 1 && prevLMConnector.ConnectItem2SymbolObject != null)

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

                else

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

            }

            _placement.PIDRemovePlacement(prevLMConnector.AsLMRepresentation());

            newConnector = _placement.PIDPlaceRun(_LMAItem, placeRunInputs);

            ReleaseCOMObjects(placeRunInputs);

            ReleaseCOMObjects(_LMAItem);

            ReleaseCOMObjects(modelItem);

            if (newConnector != null)

            {

                if (startSymbol != null)

                {

                    _LMAItem = _placement.PIDCreateItem(symbolPath);

                    placeRunInputs = new PlaceRunInputs();

                    placeRunInputs.AddSymbolTarget(startSymbol, vertices[0][0], vertices[0][1]);

                    placeRunInputs.AddConnectorTarget(newConnector, vertices[0][0], vertices[0][1]);

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

                    if (_LMConnector != null)

                    {

                        RemoveConnectorForReModelingLine(newConnector);

                        ReleaseCOMObjects(_LMConnector);

                    }

                    ReleaseCOMObjects(placeRunInputs);

                    ReleaseCOMObjects(_LMAItem);

                }

                if (endSymbol != null)

                {

                    if (startSymbol != null)

                    {

                        Dictionary<LMConnector, List<double[]>> dicVertices = GetPipeRunVertices(newConnector.ModelItemID);

                        newConnector = dicVertices.First().Key;

                    }

                    _LMAItem = _placement.PIDCreateItem(symbolPath);

                    placeRunInputs = new PlaceRunInputs();

                    placeRunInputs.AddSymbolTarget(endSymbol, vertices[vertices.Count - 1][0], vertices[vertices.Count - 1][1]);

                    placeRunInputs.AddConnectorTarget(newConnector, vertices[vertices.Count - 1][0], vertices[vertices.Count - 1][1]);

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

                    if (_LMConnector != null)

                    {

                        RemoveConnectorForReModelingLine(newConnector);

                        ReleaseCOMObjects(_LMConnector);

                    }

                    ReleaseCOMObjects(placeRunInputs);

                    ReleaseCOMObjects(_LMAItem);

                }

                foreach (var line in lines)

                    line.SPPID.ModelItemId = newConnector.ModelItemID;

                ReleaseCOMObjects(newConnector);

            }

            ReleaseCOMObjects(modelItem);

        }

        /// <summary>

        /// Remodeling 과정에서 생긴 불필요한 Connector 제거

        /// </summary>

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

        private void RemoveConnectorForReModelingLine(LMConnector connector)

        {

            Dictionary<LMConnector, List<double[]>> dicVertices = GetPipeRunVertices(connector.ModelItemID);

            foreach (var item in dicVertices)

            {

                bool result = false;

                foreach (var point in item.Value)

                {

                    if (point[0] < 0 || point[1] < 0)

                    {

                        result = true;

                        _placement.PIDRemovePlacement(item.Key.AsLMRepresentation());

                        break;

                    }

                }

                if (result)

                    break;

            }

            foreach (var item in dicVertices)

                ReleaseCOMObjects(item.Key);

        }

        /// <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)

                    {